From 9aeaf9c6f88a9facd5154fe4dc0f829fb64a09c2 Mon Sep 17 00:00:00 2001 From: Glowster Date: Fri, 17 Oct 2025 17:36:07 +0200 Subject: [PATCH 1/9] saving --- src/editflows.jl | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 src/editflows.jl diff --git a/src/editflows.jl b/src/editflows.jl new file mode 100644 index 0000000..e69de29 From fae601a7d58b13ee99e72e3714b20f069880ef3d Mon Sep 17 00:00:00 2001 From: Glowster Date: Sat, 18 Oct 2025 10:54:28 +0200 Subject: [PATCH 2/9] saving --- Project.toml | 1 + editflow_code/Project.toml | 24 +++ editflow_code/abs.txt | 108 +++++++++++ editflow_code/editflowsrun.jl | 197 +++++++++++++++++++ editflow_code/helper_funcs.jl | 60 ++++++ editflow_code/prob_model.jl | 164 ++++++++++++++++ src/Flowfusion.jl | 4 +- src/editflows.jl | 353 ++++++++++++++++++++++++++++++++++ src/types.jl | 3 + 9 files changed, 913 insertions(+), 1 deletion(-) create mode 100644 editflow_code/Project.toml create mode 100644 editflow_code/abs.txt create mode 100644 editflow_code/editflowsrun.jl create mode 100644 editflow_code/helper_funcs.jl create mode 100644 editflow_code/prob_model.jl diff --git a/Project.toml b/Project.toml index 67eeb4b..29b0fa5 100644 --- a/Project.toml +++ b/Project.toml @@ -12,6 +12,7 @@ Manifolds = "1cead3c2-87b3-11e9-0ccd-23c62b72b94e" NNlib = "872c559c-99b0-510c-b3b7-b6c96a88d5cd" OneHotArrays = "0b1bfda6-eb8a-41d2-88d8-f5af5cad476f" StatsBase = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91" +Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" [compat] Adapt = "4.1.1" diff --git a/editflow_code/Project.toml b/editflow_code/Project.toml new file mode 100644 index 0000000..552c322 --- /dev/null +++ b/editflow_code/Project.toml @@ -0,0 +1,24 @@ +[deps] +Adapt = "79e6a3ab-5dfb-504d-930d-738a2a938a0e" +CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" +CannotWaitForTheseOptimisers = "16124dda-d9fe-413b-a880-e3f4df3aa341" +Dates = "ade2ca70-3891-5945-98fb-dc099432e06a" +Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f" +Flowfusion = "5b4e93c8-7b6e-4682-b400-fc3b238f52b1" +Flux = "587475ba-b771-5e3f-ad9e-33799f191a9c" +ForwardBackward = "e879419d-bb0f-4252-adee-d266c51ac92d" +Functors = "d9f16b24-f501-4c13-a1f2-28368ffc5196" +IJulia = "7073ff75-c697-5162-941a-fcdaad2a7d2a" +LearningSchedules = "7e85a9e7-c65d-495e-8ec0-baa06f07ebbf" +Manifolds = "1cead3c2-87b3-11e9-0ccd-23c62b72b94e" +Metal = "dde4c033-4e86-420c-a63e-0dd931031962" +NNlib = "872c559c-99b0-510c-b3b7-b6c96a88d5cd" +OneHotArrays = "0b1bfda6-eb8a-41d2-88d8-f5af5cad476f" +Onion = "fdebf6c2-71da-43a1-b539-c3bc3e09c5c6" +Optimisers = "3bd65402-5787-11e9-1adc-39752487f4e2" +Plots = "91a5bcdd-55d7-5caf-9e0b-520d859cae80" +RandomFeatureMaps = "780baa95-dd42-481b-93db-80fe3d88832c" +Revise = "295af30f-e4ad-537b-8983-00126c2a3abe" +StatsBase = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91" +Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" +cuDNN = "02a925ec-e4fe-4b08-9a7e-0d78e3d38ccd" \ No newline at end of file diff --git a/editflow_code/abs.txt b/editflow_code/abs.txt new file mode 100644 index 0000000..b914fde --- /dev/null +++ b/editflow_code/abs.txt @@ -0,0 +1,108 @@ +QLQLQESGPGLVKPSETLSLTCTVPGGPISSSSYYWGWIRQPPGKGLEWIGSIYYSGSTYYNPSLKSRVTISVDTSKNQSSLKLSSGTAADTAVYYCYSNYKVDYYVDVLGKGTTVTGSS +EGKRVECGGGGGGRGGARRGGCEEEGVTFDEEGMSGGSQARGKGREGVSGRNWKGGSTGYADSVKGRFTISRDNAKNSLYLQMNSLRAEDTAFSSCAIYITLFEFLYSSFDISGQGTLFTFSS +EGQRVECGGGGGQRGRDRRGECIEEGVTFGEEGMSGGGQAKGKGREGVGGRRSKEEGGTTEEGVSVKGRFTISRDDSKSIAYLQMNSLKTEDTAVYYCTRALSADYYSSGISLYYSSLDVSGKGTPFTFSS +EVHLVESGGGLVQPGGSLRLSCAASVLTFSSFALSWVLHAPGKALEWVSAISGSGGCTYYAVTVKGRFTISREKSKNTLYMQMNSLRAEDTAVYCCAKDQQQLFSDWGQETMVTVSS +EVQLVESGGDLVQPGGSLRLSCAISGFTVSNNHVTWFRQAPGKGLEWVSLIYNAGSTIYADSVKGRFTISRENSKNIVYLQMNSVTAEGTAVYYCLGLGAKAVWGQGTVVTVSA +QVQLVQSGAEVKKPGASVKISCTASGYTITNHYMHWVRQAPGQGPEWVGVINPSGDRTVYAQKFQGKVTMTRDTSTSTVYMEVSSLKSDDTAVYYCARDNSAQEKSWWFDPWGQGTLVTVSS +EVQLVESGGGLVQPGGSLILSCAASGFTFSSHWMGWVRQAPGEGLEWVANLNQDGSETYYVDSLKGRFTISRDNTKNSLCLQMNSLRTEDTAVYFCARLGYRLAEYWGQGTLVTVSA +QVQLVQSGAEVKKPGASVKISCTASGYTITNHYMHWVRQAPGQGPEWVGVINPSGDRTVYAQKFQGKDTMTRDTSTSTVYMEVSSLKSDDTAVYYCARDNSAQEKSWWFVHWGQGTLVTVSS +QVQLVESGGGVVQPGRSLRLSCAASGFTFSSYGMQWVRQAPGKGLEWVAVISDDGSTKHYADSVNGRFTVSRDNSKNTLYLQMNSLRAEDTAVYYCAKEKGGNYMPLDYWGQGTLVIVSA +EVQLVESGGGPVKPGGSLRLSCTVSGFTFTSYSMDWVRQAPGQGLEWLSYIHNGGNDVSYADSVRGRFTISRDNAKNSVDLQMNSLRAEDTAVYYCVRDYDYSFDYWGQGILVTVSS +QVQLVQSGTEVKKPGASVKVSCKASGYTFTSYAMRWVRQAPGQRLEWMGWINAGDGNTKYSQKFQDRVTITRDTSTSTAYMELSSLRSEDTAVYYCAREMVVVMRGRSDTASGGKGTLVTVSS +QVQLVESGGGVVQPGRSLRLSCAASGFTFSSYGMHWVRQAPGKGLEWVAVIWYDGSNKYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCARDVVTGYSNLSGLGYWGQGTLVTVSP +EVQLVESGGGLVQTGGSLRLSCAASGFTIINYWMHWVRQAPGKGLVWVSHINGDGRRTTYADSVKGRFTISRDDAKNTVYLQMNSLRDEDTAVYYCARDRFYSPGHWGQGILVTVSS +QVQVVQSGAEVKRPGASVTVSCKPSGYTFTSYGISWVRQAPGQGLEWMGWISIYNGNTKYAQTLQGRVTLTRDTSTNTAYMELRSLRSDDTAVYYCARGGPACCNGGTCYGDAFDFLGQGTTGTVSS +EVQLVESGGGLVQPGGSLILSCAASGFTFSSHWMGWVRQAPGEGLEWVANLNQDGSETYYVDSLKGRFTISRDNTKNSLYLQMNSLRTEDTAVYFCARLGYRLAEYWGQGTLVTVSA +QVQLGQSGAEVEKPGASVKVSCKASGYTFTGYYMHWVRQAPGQGLEWMGWINPNSGGTNYAQKFQGWVTMTRDTSISTAYMELSRLRSDDTAVYYCARDYSSGWYYFDYWGQGTLVIVSP +QVELRESGRVMVRPSETLSLTCTVSGGSISSYYWSWIRQPPGKGLEWIGYIYYSGSTNYNPSLKSRVTISVDTSKNQFSLKLGSVTAADTAVYYCARRKVVPADISQPHNDAFDIWGQGIMDSVSS +QLQLQESGPGLVKPSETLSLTCTVSGGSISSSSYYWGWIRQPPGKGLEGIGSIYYSGSTYYNPSLKSRVTISVDTSKNQFSLKLSSVTAADTAVYYCARHRSGLELLSYYYYYMDVWRKGTTHTFSS +QVQLVQSGAEVKKPGASVKVSCKASGYTFTSYYMHWVRQAPGQGLEWMGIINPSGGSTSYAQKFQGRVTMTRDTSTSTVYMELSSLRSEDTAVYYCARVGVITGTTGGWFDPWGQGTLVTVSS +QVQLVQSGAEVKRAGASVKVSCKASGYTFTSYYMHWVRQAPGQGLEWMGIINPSGGSTSYAQKFQGRVTMTRDTSTSTVYMELSSLRSEDTAVYYCATSGVGATPFDYWGQGTLVTVSS +QVLLVQSGTEVKKPGASVKVSCKAYGYSFTTYGTTWVRQAQGLEYMGWISPYNGDTNYAQELQSRVTMTTDTSTSTAYMELRSLTYDDTAVYCWTRSGLQYDSGMNGGGQGTAVTVSS +QVQLVQSGAEVKKPGASVKVSCRTSGYSFTTYAIHWVRQAHGQRLAWVGCINADNGNTQYSQSFQGRVTITRDTSASTAYMELSSLRSEDAAVYYCARDLAFYGSFGGDYCGQGALIAFSS +QVQLQESGPGLVKPSETLYLTCTVSGGSISSYYWSWIRQPPGKGLEWIGYIYYSGSTNYNPSLKSRVTKSVDTSKNQFSPKLSSVTAADTAVYYCARDGGGSGSYYPHYYYYYGMDVWGQGFSDTVSS +QVQLVQSGAEVKKPGASVKVSCKASGYTFTSYGISWVRQAPGQGLEWMGWISAYNGNTNYAQKLQGRVTMTTDTSTSTAYMELRSLRSDDTAVYYCAKAGGYSYGWGLFDPWGQGTLVTVSS +QVQLVQSGAEVKKPGASVKVSCKASGYTFTSYAMHWVRQAPGQRLEWMGWINAGNGNTKYSQKFQGRVTITRDTSASTAYMELSSLRSEDTAVYYCARSITPSGYDYVYFDYWGQGTLFTVSS +EVQLVESGGGLVQPGGSLRLSCAASGFTFSSYEMNWVRQAPGKGLEWVSYISSSGSTIYYADSVKGRFTISRDNAKNSLYLQMNSLRAEDTAVYYCARDGSGGSLGWFDPWGQGTLVTVSS +EVQLVESGGGLVQPGGSLRLSCAASGFTFSNYAMTWVRQAPGKGLEWVSSISEAGGSSYYADSVKGHFTISRDNSKNTLYLQMNSLRAEDTAVYYCAKGLLYSGRQALVDYWGQGTLVTVFS +QVQLQQSGPGLVKPSQTLSLTCAISGDSVSSNSAVWNWIRQSPSRGLEWLGRTYYRSKWYNDYAVSMKSRVTINTDTSRNQFSLQLNSVTPEDTAVYFCARDQSGWYATSWYFDFWGQGPLATLSS +EVQLVESGGGLVQPGGSLRLSCAASGFTVSSNYMSWVRQAPGKGLEWVSVIYSGVTTYYADSVKGGLTISRDTSKNTLYLQMNSLRAEDTAVYYCARDRSRNWGFDCLGQGTLGTGFS +QVQLVQSGAEVKKPGASVKVSCKTSGYTFSTYAITWVRQAPGQGLEWVGWISGYNGNTRYGEKLLGRVTMTTDTSTSTAYMELRSLRSDDTAVYYCVAAPTSSDCRSTNCPRGHYYYGVDVWGQGTTVTVSS +EVQLVESGGGLVQPGGSLTLSCAASAFLFSSYWMHWVRQAPGKGLVWASRINSDGRSTKYADSVTGRFTTSRDNAKNTLYLQMNSRRDEDPAVHYCAREFGPALDDWGQGTLVTVAS +QVQLQESGPGLVKPSETLPLTCTVSGVSISSYLWSWIRQSPGKGLEWIGYIHYSVSTNYNPSLKSRVTMSVDTSKKQFSLKLSSVTAADTAVYYCARCTGAGRSACDAFDIWGQGTMVTVSS +QVQLVQSGAEVKKPGSSVNVSCKASGGTFSSYTISWVRQAPGQGLEWMGRIIPILGIANYAQKFQGRVTITADKSTSTAYMELSSLRSEDTAVYYCARGLWFGELLYSWFDPWGQGTLFSVSS +QVQRVQSGAEVKKPGASVKCSCKASGYTFTSYGISWVRQAPGQGLEWMGWISAYNGNTNYAQKLQGRVTMTTDTSTSTAYMELRSLRSDDTAVYYCARDLQGENYDFWSGYYTGPVWYMDVWGKVFTDTVSS +QVTLRDSVXALVKPTHTLTLTCTFSGFSLSSSGMCVSWIRHPPGNSLEWLALIDWDDDKYYSTSLKTRLTISKDTYKNQVVLTMTNMDPVDTATYYCSRIQAEEGTEYYIDYRGQGNLVNVSS +QVQLVESGGGVVQPGRSLRLSCAASGFTFSSYGMHWVRQAPGKGLEWVAVIWYDGSNKYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVDYCERPAAIWSGSYIDDWSQGTLVIVSS +EVQLVESGGGLVQPGGSLRLSCAASGFILTNYWMNWVRQAPGKGLEWVANIKRDGSETYYVDSVKGRFTISRDIAKNLLYLQMNSLRAEDTAIYYCVRGSAGAKDYWGQGSLVNVSS +QVQLVQSGAEVKKPGASVKISCTASGYTLTNHYMHWVRQAPGQGPEWVGVINPSGDRTVYAQKFQGKVTMTRDTSTSTVYMEVSSLKSDDTAVYYCARDNSAQEKSWWFDPWGQGILVTVSS +EVQLVESGGGLVQPGGSLRLSCAASGFTFSSYSMNWVRQAPGKGLEWVSAISGSGGSTYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAKHPGSIAGEFDYWGQGTLVTVSS +QVQLVQSGAEVKKPGASVKVSCKASGYTFTSYGISWVRQAPGQGLEWMGWISAYNGNTNYAQKLQGRVNMTTDTSTSTAYMELRSLRSDDTAVYYCARDGDLAVAGISQDWGRGTLVTISS +QVQLVQSGAEVKKPGASVKVSCKASGYTFTSYYMHWVRQAPGQGLEWMGIINPSGGSTSYAQKFQGRVTMTRDTSTSTVYMELSSLRSEDTAVYYCARVRKCGGDCKRVWFDPWGQGTLVIVSS +QVQLVQSGAEVKKPGASVKVSCKASGYTFTSYGISWVRQAPGQGLEWMGWISAYNGNTNYAQKLQGRVILTSDTSTSTAYMQLRSLRSDDTAVYYCARTPERQLGARSEYWGERALGSVSS +EVQLVTSEVGPLEPGGSLKLSCETTGFIFSDSGMHWVRQASGKGLEWVGRIRSKANSYTTAYAASVKGRFTISRDDSKNTAYLQMNSLKTEDTAVYYCTRYPAGQIMPTPFDYWGQGALVTFSS +QVYLQQSGPGLVKPSQTLSLTCAISGDSVSSNIAAWNWIRQSPSRGLEWLGRTYYKSKWYNDYAVSVKSRITINPATTKNQFSLQLNSVTPEDTAVYYCARGPGGLVGFDFWGQGTLVTVSS +QVQLVQSGAEVKKPGASVKVSCKASGYTFTSYGISWVRQAPGQGLEWMGWISAYNGNTNYAQKLQGRVTMTTDTSTSTAYMELRSLRSDDTAVYYCARGRYYDSSGYPLYWYFDLWGRGTLVTVSS +QVQLVQSGAAVKKPGASVRVSCQASGYTFTDYMMHWVRQAPGQRLEWMGWITSGNGNTKYSENFQGRVTITRDTSASTAYMELSSLTSEDTAVYYCARALTRSSNWFDPWGQGSFDTIST +EVQVVEHGGGLVQPGGSLRLSCAASGFTVSSNYMSWVRQAPGKGLEWVSVIYSGGSTYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCARGRIAFSYWGQGTLVTVSS +QVQLVQYGSDVKKPGASVKVSCKASGYTFTSYGISWVRQAPGQGLEWMGWISAYNGNTNYAQKLQGRVTMTTDTSTSTAYMELRSLRSDDTAVYYCARDLRAVAGTIFRGVLSYWGQGILVTVSS +QVLLVQSGAEVKKPGASVKLSCKGFGFMFTRYAIHWVRQAPGQGLEWMGCIVPVDGKTYYSQRFQDKVTITRDTSASTAYVDVSRLTPEDTAVYYCARDLVGAGYFDYWGQGALVTVSP +EVQLVESGGGLVKPGGSLRLSCAASGFTFSNAWMSWVRQAPGKGLGWVGRIKSKTDGGTTDYAAPVKGRFTISRDDSKNTLYLQMNSLKTEDPSVYYCTRDLRTPVVRIVEWLHYTQGGGTPTTVTPSS +EVHLVESGGGLVKPGGSLRLSCAASGFTVSSNYMSWVRQAPGKGLEWVSVIYSGGSAYYADSVKGRFTISRHNSKNTLYLQMNSLRAEDTAVYYCGRCRRRAAAGTGYYDDFDIWGQGTMVTVIS +QVQLQESGPGLVKPSETLSLTCTVSGGSISSYYWSWIRQPPGKGLEWIGYIYYSGSTNYNPSLKSRVTISVDTSKNQFSLKLSSVTAADTAVYYCARMKYGSELLDYYYYMDVWGKGTTVTVSS +QVQLVQSGAEVKKPGASVKVSCKASGYTFTSYGIRWVRQAPGQGLEWMGWISADNGNTNYAQKLQGRVTMTTDTSTSTAYMELRSLRSDDTAVYYCARVRGLSLGFDYWGQGTLVNVSS +QVRLVQYGANVKKPGASVKVSCKASGYTFTGYYMHWVRQAPGQGLEWMGWINPNSGGTNYAQKFQGWVTMTRDTSISTAYMELSRLRSDDTAVYYCARDQNINDAFDIWGQGIIDTVSS +EVQMAKYGGGPDKPGGSMKITCAASGFTFSSYSMNWVRQAPGKGLEWVSSISSSSSYIYYADSVKGRFTISRDNAKNSLYLQMNSLRAEDTAVYYCARDGKRGSVVVAATLGWGYYYYGMDVLFHWTTVTVSS +QVQLVESGGGVVQPGRSLRLSCAASGFTFSSYGMHWVRQAPGKGLEWVAVIWYDGSNKYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCASLMSFGESRYYYYYGMDVWGQGSTVSVAS +QVQLVQSGAEVKKPGASVKVSCKASGYTFTNYGISWVRQAPGQGLEWMGWISAHNGNTNYAQNLQGRVTMTTDTSTSTAYMELRSLRSDDTAVYYCARGTKAFDIWGQVIIVTVSS +QVQLVQSGAEVKKPGASVKISCTASGYTITNHYMHWVRQAPGQGPEWVGVIDPSGDRTVYAQKFQGKVTMTRDTSTSTVYMEVSSLKSDDTAVYYCARDNSAQEKSWWFDPWGQGTLVTVSS +EVQLVESGGGLVQPGGSLRLSCAASGFTFSSFAMSWVRQAPGKGLEWVSGIRGSGGNTHYGDSVKGRFTISRDNSKNTLYLQIDGLRAEDTALYYCAKATGVANFWSHDAFDIWGQGTIVTVSS +QEKGGQYGGKVKKPRSWVKVSGKASRGTFSSYTISWVRQAPGQGLEWMGRIIPILGIANYAQKFQGRVTITADKSTSTAYMELSSLRSEDTAVYYCASSGYCSSTSCYDPLKDAFDIWGQGNMVIDYS +QVQLQESGPGLVKPSETLPLTCTVSGVSLSSYLWSWIRQSPGKGLEWIGYIHYSVSTNYNPSLKSRVTMSVDTSKKQFSLKLSSVTAADTAVYYCARCTGAGRSACDAFDIWGQGTMVTVSS +EVQLVESGGGLVKPGGSLRLSCAASGFTFSSYSMNWVRQAPGKGLEWVSSISSSSSYIYYADSVKGRFTISRDNAKNSLYLQMNSLRAEDTAVYYCARARAPWGQGNLVTLSS +QLQLQESGPGLVKPSETLSLNCTVSGGSISSSSYYWGWIRQPPGKGLEWIGSIYYSGSTYYNPSLKSRVTISVDTSKNQFSLKLSSVTAADTAVYYCARPSHMITFGGVIVTRSFDYWGQRTLVTVSS +QVQLVQSGAEVKKPGSSVKVSCKASGGTFSSYTISWVRQAPGQGLEWMGRIIPILGIANYAQKFQGRVTITADKSTSTAYMELSSLRSEDTAVYYCARGGGYCSGGSCYPDAFDIWGQGTMVTVAS +QVQLVQSGAAVKTPGASVKVSCKASGYNFTNYGISWVRQAPGQGLEWMGWISAHNGNTNYAQNLQGRVTMTTDTSTSTAYMELRSLRSDDTAVYYCAGGTKAFDIWGQGTMVIVFS +QITLKESDPTLVKPTQTLTLTCTFSVFSLSTSGVGVGWIRQPPGKALEWLALIYWDDDKRYSPSLKSSLTITKDTSKNQVVLTMTNMDPVDTATYYCAHRPYGDARDADDIGDQGAMVTVSS +QVQLVQSGAEVKKPGSSVKVSCKASGYTFTSYGISWVRQAPGQGLEWMGWISAYNGNTNYAQKLQGRVTMTTDTSTSTAYMELRSLRSDDTAVYYCARDGAVSHTSLECSGGSCYDAFDIWGQVTMNTVSS +QVQLVQSGAEVQKPGASVKVSCKASGYIFTSYFIHWMRQAPGQGLEWMGSINPRGGNTNYALKFQGRVTMTRDTSTGTVHMELSRLGSEHTAVFYCAKGSGRPDLARLSRFGPWGQGTLGIVSS +QVQLVKSGDEVKKPGASVKVYCKASGYTFTSYAMHWVRQAPGQRLEWMGWINAGNGNTKYSQKFQGRVTITRDTSASTAYMELSSLRSEDTAVYYCARVVVPAAMVNWFDPWGQGTLVTVSS +QVQLVQSGAEVKKPGASVKVSCKASGYTFTSYAMHWVRQAPGQRLEWMGWINAGNGNTKYSQKFQGRVTITRDTSASTAYMELSSLRSEDTAVYYCASAIVATMAFDYWGQGTLVTVSS +QVQLVQSDADVKKPLASVEVSCKASGGTFSSYTISWVRQAPGQGLEWMGRIIPILGIAHYAQKFQGRVTITADKSTSTAYMELSSLRSEDTAVYYCASEEKGSMMVARAFDYWGQVILVTASS +QVQLVQSGTEVKRPGASVKVACKAYGYTFTSYGISWVRQAPGQGLEWMGWISAYNGNTNYAQKLQGRVTMTTDTSTSTAYMELRSLRSDDTAVYYCARGHGECSSTSCYGLNVDDYWGQGTLVTVSS +EVQLVESGGGLVQPGGSLILSCAASGFTFSSHWMGWVRQAPGEGLEWVANLNQDGSETYYVDSLKGRFTISRDNTKNSLYLQMNSLRTEDTAMYFCARLGYRLAEYWGQGTLVTVSA +QVQLVQSGAEVKKPGASVKVSCKASGYTFTGYYMHWVRQAPGQGLEWMGWINPNSGGTNYAQKFQGWVTMTRDTSISTAYMELSRLRSDDTAVYYCAREVVLTYYYGSGSYYNVPGSPGGQYYFDYWGQGTLVIVSS +EVQLVESGGGLVQPGGSLILSCAASGFTFSSHWMGWVRQAPGEGLEWVANLNQDGSDTYYVDSLKGRFTISRDNTKNSLYLQMNSLRTEDTDVYFCARLGYRLAEYWGQGTRVIVSA +EVQLVESGGGLVKPGGSLRLSCAASGFTFSNACMSWVRQAPGKGLEWVGRIKSKTDGGTTDYAAPVKGRFTISRDDSKNTLYLQMNSLKTEDTAVYYCTTVSGDIVVVPAAIPTRGSIAVAGTFGYWGQGALVTVSS +EVQLLESGGGLVQPGGSLRLSCAASGFTFSSYAMSWVRQAPGKGLEWVAAISGSGGSTYYADSVKCRFTSSRDNSKNTLYLQMNSLRAEDTAVYYCAKVSRYYYGSGIEFDYRGQGTLVNVSS +QVQLVQSGAEVKKPGASVKVSCKASGYTFTSYGISWVRQAPGQGLEWMGWISAYNGNTNYAQKIQGRVTMTTDTSTSTAYMELRSLRSDDTAVYYCARGVYPDDSSDHPFDYWGQGTLVSVSP +QVQLVESGGGVVQPGRSLRLSCAASGFTFSSYAMHWVRQAPGKGLEWVAVISYDGSNKYYADSVKGRFTISRDNSKSTLYLQMNSLRAEDTAVYYCARDPDGYWSGGSCYLYYFDYWGQGILVTGSA +QITLKESGPTLVKPTQTLTLTCTFSGFSLSTSGVGVGWIRQPPGKALEWLALIYWDDDKRYSPSLKSRLTITKDTSKSQVVLTMTNMDPVDTATYYCAHFGFGELLLENGAQGTLVTVSS +QVQLVQSGAEVKKPGASVKVSCKASGYTFTSYGISWVRQAPGQGLEWMGWISAYNGNTNYAQKLQGRVTMTTDTSTSTAYMELRSLRSDDTAVYYCARDRPTVGGSTRIGFRGPGNLGTGSS +EVQVVESGGGLVQPGGSLRLSCAATGFTVNRNHVKWVRQAPGKGLECVSVILDTGVTYYADAVKGRFTISRDNSKNTVNLEMNSLRAEDTAIYYCGGYGANSVWGQGSLGTVSP +EVELVESGGGLVQPGGSLRLSCAASGFNCNIYAMHWVRQAPGKGLEFLSSVLGNGAKRQYASSVKGSFTMSRDNSKTTLHLHMGSLRPDDTALYYCARDKDSGYAFVYWGQGALLTVSS +QVQLVQSGAEVKKPGSSVKVSCKASGDTFSSYTISWVRQAPGQGLEWMGRIIPILGIANYAQKFQGRVTITADKSTSTAYMELSSLRSEDTAVYYCASLAYCGGDWYSTNRNYYFDDWGQGTLINVSS +EVQLVKSGGGLVKPGGSLRLSCAASGFTFSNAWMSWVRQAPGKGLEWVGRIKSKTDGGTTDYAAPVKGRFTISRDDSKNTLYLQMNSLKTEDTAVYYCTTDAVPVGYWGQGFLVTASS +QVQRVQAGAAVKKPGTSVKVSCKASGGTFSSYTISWVRQAPGQGLEWMGRIIPILGIANYAQKFQGRVTITADKSTSTAYMELSSLRSEDTAVYYCARDYGGRLAAMGYYWGQGSLVTVAS +QVQLQESGPGLVKPSGTLSLTCAVSGGSISSSNWWSWVRQPPGKGLEWIGGIYHSGSTNYNPSLKSRVTISVDKSKNQFFLKLSSVTAADTAVYYCASDNWNYSWFDPWGGEALVAISS +QVQLVQSGAAVKKPGASVQVSCKASGYTFTSYGISWVRQAPGQGLEWMGWISAYNGNTNYAQKLQGRVTMTTDTSTSTAYMELRSLRSDDTAVYYCARESGGWYYFDNWGQGTLVTVSS +EVLLVXXXGGLVQPXXSLRLSXAASGFTFTDYWMHWVRQSPGKWLVWVSRINNDVSDTIYADSVKGRFTLSRDKAKNTLYLQMNSLRVEYTAVYYCARGGWSHGFDIWGQGKMVTVSS +EVQLVESGGGLVQPGVSLRLSCAASGFTFSSYAMHWVRQAPGKGLEYVSAISSTRGSTYSANAVKGRFTISIENSKKTLYLQMGRLRAEDSAVYYWASMGNLRYLDWLPTVPDDFEIWGEGAMGTVSS +QVQLVQSGAEVKKPGASVKVFCKASGYTFTNYIMHWVRQAPGQRLEWMGWISAGNGNTNFSQDFQDRVTFTRDTSESTDYMELSSLNSEDTAVYYCAREGFEPWGQGNLVNVSS +QVQLVQSGAEVKKTGASVKVSCKASGYTFTSYGISWVRQAPGQGLEWMGWISAYNGNTNYAQKLQGRVTMTTDTSTSTAYMELRSLRSDDTAVYYCARSSDIVVVPDYYGMDVWGQGTTVTVSS +QLQLQESGPGLVKPSETLSPTCTVSGGSISSSSYYCGWIRRPPGKGLEWIGSIYYSGSTYYNPSLKSRVTISVDTSQNQFSLKLSSVTAADPAVDYCARHLVERPFGYWGQGTLGTVSS +QVQLVQSGAEVKKPGASVKVSCKASGYTFTSYGISWVRQAPGQGLEWMGWISAYNGNTNYAQKLQGRVTMTTDTSTSTAYMELRSLRSDDTAVYYCASDYYDTSLPGDYWRPRTLVPVSS +QVQLVPSGAAVKKPGASVKVSCKASGYTFTSYGISWVRQAPGQGLEWMGWISAYNGNTNYAQKLQGRVTMTTDTSTSTAYMELRSLRSDDTAVYYCAREWVGFDPWGQGTLVTVSP +QLQLQESGPGLVKPSETLSLTCTVSAGSISSNNYFWGWIREPPGKGLEWIGSVYSSGSTYYNPSLKGRVTISVDTSKNQFSLKLTSVTAADTAVYYCATPWRATYYYGSSGYYGWDAFDTWGQGTMVTVFS +QVQLVQSGAEVKKPGASVKVSCKASGYTFTSYGISWVRQATGQGLEWMGWISAYNGNTNYAQKLQGRVTMTTDTSTSTAYMELRSLRSDDTAVYYCARGDILPVYFCHFGAQGPGVTVST +QVQLVESGGGVVQPGRSLRVSCAASGFTFSNYGMHWVRQAPGRGLEWVAVILKDGSKDDYADSVKGRFTISRENSKNTLYLQMNSLRAEDTVFFFCGRDDEGVQNGFVGGGQGKMAPFFS +EVQLVASGGVLVKPEGSLRLSCAASGFTFSSYSMNWVRQAPGKGLEWVSSISSSSSYIYYADSVKGRFTISRDNAKNSLYLQMKSLRAEDTAVYYCATSGYDWRYWGQGSLLTVSS +EVQVVESGGDLVHPGGSLRLSCVASGFTVSNNHVSWVRQAPGKGLEWVSFIHNSGTTHYADSVKGRFTISRDNSRNTVYLQMNSVRVEDTAVYYCMGYGGNSVWGQGTLVTVSS +QVQLVQSGAEVKKPGASVKVSCKASGYTFTNYGINWVRQAPGQGLEWMGWIGAYNAYTNYAQKLQGRVTMTTDASTNTAYMELRSLRSDDTAVYYCAREYSGYDLEDYWSQGTLVTVAS +EVQLVESGGGPVKPGGSLRLSCTVSGFTFTSYSMDWVRQAPGQGLEWLSYIHNGGNDVSYADSVRGRFTISRDNAKNSVDLQMNSLRAEDTAVYYCVRDYDYSFDDWGQGILVTVSS +HLQLKESGTRLLKPSETLSLTCTVSCSYISSSSYYWGWIRQPPGKGLEWIGSIYYSGSTYYNPSLKSRVTISVDTSKNQFSLKLSSVTAADTAVYYCARPLVVPAAYFDYWGQGTLVIVSS +QVQLVQSGAEVKKPGASVKVSCKASGYTFTSYGISWVRQAPGQGLEWMGWISAYNGNTNYAQKLQGRVTMTTDTSTSTAYMELRSLRSDDTAVYYCARDGPSYSSGTGIDYWGQGTLFTVSS +QVQLVQSGSEVKKSGASVKVSCKASGYTFTSYGISWVRQAPGQGLEWMGWISAYNGNTNYAQKLQGRVTMTTDTSTSTAYMELRSLRSDDTAVYYCARDAGAAMADYGMDVWGQGTTVTVSS +QVQLVQAGAEVKKPGASVKVSCKASGYTFTSYGISWVRQAPGQGLEWMGWISAYNGNTNYAQKLQGRVTMTTDTSTSTAYMELRSLRSDDTAVYYCARDFPTYYYDSSGYYPAGWGHGTLVTVSS +QVKLVQSGAEVKKPGSSVKVSCKASGGTFSSYTISWVRQAPGQGLEWMGRIIPILGIANYAQKFQGRVTITADKSTSTAYMELSSLRSEDTAVYYCAREGSGPNWFDPWGQGTLVTVFS +EVQLVESGGGLVKPGESLRLSCAASGFTFSNAWMGWVRLAPGKGLEWLGRFINKPGGGTADYSAPVRGRYIISRDDSKDTLYFEMKSLKTEDTGVYYCTTSLTTGGFDFWGQGTMVTVSS \ No newline at end of file diff --git a/editflow_code/editflowsrun.jl b/editflow_code/editflowsrun.jl new file mode 100644 index 0000000..0c137bf --- /dev/null +++ b/editflow_code/editflowsrun.jl @@ -0,0 +1,197 @@ +using Pkg +Pkg.activate(@__DIR__) +#Pkg.instantiate() +using Revise + +using Random +using Statistics +using Adapt +using Functors +using Flux +using Onion +using RandomFeatureMaps +using Zygote +Pkg.develop(path=joinpath(@__DIR__, "..")) +using Flowfusion +const FF = Flowfusion +include(joinpath(@__DIR__, "prob_model.jl")) +include(joinpath(@__DIR__, "helper_funcs.jl")) + +import CUDA + +# Device helpers +const _gpu_enabled = try + CUDA.has_cuda() +catch + false +end + +to_dev(x) = _gpu_enabled ? Adapt.adapt(CUDA.CuArray, x) : x +to_cpu(x) = _gpu_enabled ? Adapt.adapt(Array, x) : x +# move x to the same device type as y (Array or CuArray) +to_same_device(x, y) = (_gpu_enabled && (y isa CUDA.CuArray)) ? Adapt.adapt(CUDA.CuArray, x) : Adapt.adapt(Array, x) + +# Load PM target (brings PM and AA20) + +function make_minibatch(B::Int, P::FF.EditFlow; rng=Random.default_rng()) + K = P.k + x0s = Vector{FF.DiscreteState}(undef, B) + x1s = Vector{FF.DiscreteState}(undef, B) + for b in 1:B + # x1 from true PM + seq1 = sample(PM; rng=rng) + @assert all(1 .<= seq1 .<= K) + x1s[b] = FF.DiscreteState(K, seq1) + # x0: uniform tokens with random length in 10:30 (no BOS in x0) + L0 = rand(rng, 1:10) + seq0 = rand(rng, 1:K, L0) + x0s[b] = FF.DiscreteState(K, seq0) + end + ts = rand(rng, Float32, B) + return x0s, x1s, ts +end + +struct EditFlowModel{L} + layers::L +end +Flux.@layer EditFlowModel + +function EditFlowModel(; d=128, num_heads=8, nlayers=6, rff_dim=128, cond_dim=128, K::Int) + embedding = Flux.Embedding(K + 2 => d) + time_embed = Flux.Chain(RandomFourierFeatures(1 => rff_dim, 1.0f0), Dense(rff_dim => cond_dim)) + blocks = [Onion.AdaTransformerBlock(d, cond_dim, num_heads) for _ in 1:nlayers] + head_combined = Dense(d => 2K + 1, bias=false) + rope = RoPE(d ÷ num_heads, 4096) + return EditFlowModel((; embedding, time_embed, blocks, head_combined, rope, K)) +end + +function (model::EditFlowModel)(t, Xt_ms) + m = model.layers + X = FF.tensor(Xt_ms) + X = ndims(X) == 1 ? reshape(X, :, 1) : X + L, B = size(X) + + pmask = Zygote.@ignore FF.getlmask(Xt_ms) + Xp = X .+ 1 + H = m.embedding(Xp) + + t = ndims(t) == 0 ? fill(Float32(t), B) : Float32.(t) + cond = m.time_embed(reshape(t, 1, B)) + + cond = to_same_device(cond, H) + pmask = Zygote.@ignore to_same_device(pmask, H) + rope = Zygote.@ignore to_same_device(m.rope[1:L], H) + + for blk in m.blocks + H = blk(H; cond, rope, kpad_mask=pmask) + end + return m.head_combined(H) +end + +# Training (GPU if available) +function train_editflow!(P::FF.EditFlow, + model; + epochs::Int=1, + steps_per_epoch::Int=100, + batch_size::Int=64, + lr::Float32=1f-2, + seed::Int=42, + print_every::Int=25) + + rng = Random.MersenneTwister(seed) + Random.seed!(seed) + + # Move model to device (GPU if available) + model = Functors.fmap(to_dev, model) + opt_state = Flux.setup(Flux.Adam(lr), model) + + for epoch in 1:epochs + for step in 1:steps_per_epoch + + # 1) Minibatch Sampling + x0s, x1s, ts = make_minibatch(batch_size, P; rng=rng) + + # align_and_batch basically + Z0, Z1 = FF.align_and_batch(P, x0s, x1s) + + # + Zt, Xt = FF.interpolate_Z_elementwise(P, Z0, Z1, ts) + + #Append BOS token to the beginning of the batch + bos = P.bos_token + Zt = vcat(fill(bos, 1, batch_size), Zt) + Xt = vcat(fill(bos, 1, batch_size), Xt) + Z1 = vcat(fill(bos, 1, batch_size), Z1) + + transition_mask = FF.transition_mask_from_Xt(P, Xt) + edit_multiplier = FF.remaining_edits(P, Zt, Z1) + + den = 1f0 .- P.κ.(ts) + den = max.(den, 1f-6) + scheduler_scaling = P.dκ.(ts) ./ den + + # 3) Masked state (CPU → device) + lmask = Xt .!= P.padding_token + cmask = trues(size(lmask)) + Xt_ms = FF.MaskedState(FF.DiscreteState(P.k, Xt), cmask, lmask) + + ts_d = to_dev(ts) + Xt_ms_d = to_dev(Xt_ms) + Tmask_d = to_dev(transition_mask) + Emult_d = to_dev(edit_multiplier) + sched_d = to_dev(reshape(Float32.(scheduler_scaling), 1, 1, :)) + #print("RE???") + + # 4) Forward + loss + update (on device) + loss, grad = Flux.withgradient(model) do m + M = m(ts_d, Xt_ms_d) + l = FF.edit_loss(P, M, Tmask_d, Emult_d, sched_d; eps=1f-8) + # INSERT_YOUR_CODE + if isnan(l) + println("Maximum element of M: ", maximum(M)) + end + l + end + Flux.update!(opt_state, model, grad[1]) + + if step % print_every == 0 + @info "train2" epoch step loss=Float32(loss) + end + end + end + + # Move model back to CPU for sampling + return Functors.fmap(to_cpu, model) +end + +# Run training + sampling + CE +K = PM.K + +P = FF.EditFlow(K; bos_token=0) + +model = EditFlowModel(; d=128, num_heads=8, nlayers=4, rff_dim=128, cond_dim=128, K=K) + +# Train; returned model is on CPU +model = train_editflow!(P, model; epochs=2, steps_per_epoch=150, batch_size=256, lr=1f-3) + +rng = Random.MersenneTwister(42) +println("\n=== True PM samples (20) ===") +for i in 1:20 + seq = sample(PM; rng=rng) # Vector{Int} in 1..K_AA + aa_str = String(collect(AA20[seq])) + println("[", i, "] ", aa_str) +end + +samples = sample_gen_10_strings(P, model; ts=0f0:0.01f0:1f0) + +println("\n=== Model samples (10) ===") +for (i, s) in enumerate(samples) + if s isa AbstractString + println("[", i, "] ", s) + elseif s isa AbstractVector{<:AbstractString} + last_str = isempty(s) ? "" : s[end] + println("[", i, "] traj_last=", last_str, " (len=", length(s), ")") + else + println("[", i, "] (raw) ", s) + end +end \ No newline at end of file diff --git a/editflow_code/helper_funcs.jl b/editflow_code/helper_funcs.jl new file mode 100644 index 0000000..2542202 --- /dev/null +++ b/editflow_code/helper_funcs.jl @@ -0,0 +1,60 @@ +# Sampling helpers +function state_to_PM_string(P::FF.EditFlow, st::FF.DiscreteState) + xs = FF.tensor(st) + pad = hasfield(typeof(P), :padding_token) ? P.padding_token : -1 + io = IOBuffer() + @inbounds for tok in xs + if tok == 0 + write(io, '>') + elseif tok == pad + continue + else + write(io, AA20[tok]) + end + end + return String(take!(io)) +end + +states_to_PM_strings(P::FF.EditFlow, sts::Vector{<:FF.DiscreteState}) = + [state_to_PM_string(P, s) for s in sts] + +function sample_gen_n(P::FF.EditFlow, model; n::Int=10, ts=0f0:0.01f0:1f0, rng=Random.default_rng()) + gens = Vector{Any}(undef, n) + for i in 1:n + x0s, _, _ = make_minibatch(1, P; rng=rng) + bos = P.bos_token + toks = collect(FF.tensor(x0s[1])) + x0_bos = FF.DiscreteState(P.k, vcat([bos], toks)) + gens[i] = FF.gen(P, x0_bos, model, ts) + end + return gens +end + +function sample_gen_10_strings(P::FF.EditFlow, model; ts=0f0:0.01f0:1f0) + outs = sample_gen_n(P, model; n=20, ts=ts) + return map(outs) do o + if o isa FF.DiscreteState + state_to_PM_string(P, o) + elseif o isa AbstractVector{<:FF.DiscreteState} + states_to_PM_strings(P, o) + else + o + end + end +end + +final_state_from_gen(res) = res isa FF.DiscreteState ? res : (res isa AbstractVector{<:FF.DiscreteState} ? last(res) : res) + +function to_aa_tokens(P::FF.EditFlow, st::FF.DiscreteState) + xs = FF.tensor(st) + pad = hasfield(typeof(P), :padding_token) ? P.padding_token : -1 + toks = Vector{Int}() + @inbounds for tok in xs + if tok == 0 || tok == pad + continue + else + push!(toks, Int(tok)) + end + end + return toks +end \ No newline at end of file diff --git a/editflow_code/prob_model.jl b/editflow_code/prob_model.jl new file mode 100644 index 0000000..08f3a22 --- /dev/null +++ b/editflow_code/prob_model.jl @@ -0,0 +1,164 @@ +# ===================== Target: ProfileMixtureEOS from examples/abs.txt ===================== +# 20 AA alphabet (no '#', no '-') +const AA20 = collect("ACDEFGHIKLMNPQRSTVWY") +const TOK2ID_AA = Dict{Char,Int}(c => i for (i,c) in enumerate(AA20)) # 1..20 +const K_AA = length(AA20) + +# encode and truncate to a random length in 10:20 (inclusive), reproducible via `rng` +function encode_line_AA(line::AbstractString; rng::AbstractRNG, trunc_range::UnitRange{Int}=10:20) + maxlen = rand(rng, trunc_range) + s = uppercase(strip(line)) + out = Int[] + sizehint!(out, min(length(s), maxlen)) + for ch in s + if haskey(TOK2ID_AA, ch) + push!(out, TOK2ID_AA[ch]) + if length(out) == maxlen; break; end + end + end + return out +end + +struct ProfileMixtureEOS + K::Int + parents::Vector{Vector{Int}} + weights::Vector{Float64} + base_token_probs::Vector{Vector{Vector{Float64}}} # per m, per t + L::Vector{Int} + background::Vector{Float64} + mode::Symbol + h_tail::Float64 + h_inside::Float64 # end hazard for t ≤ L_m + alpha::Float64 + beta::Float64 +end + +function ProfileMixtureEOS(parents::Vector{Vector{Int}}; + K::Union{Int,Nothing}=nothing, + weights::AbstractVector=Float64[], + α::Real=1.0, β::Real=20.0, + background::Union{AbstractVector{<:Real},Nothing}=nothing, + mode::Symbol=:soft, h_tail::Real=0.99, h_inside::Real=0.001) + K === nothing && (K = maximum([isempty(p) ? 1 : maximum(p) for p in parents])) + @assert all(all(1 .<= p .<= K) for p in parents) + @assert mode in (:hard, :soft) + if mode === :soft + @assert 0.0 < h_tail < 1.0 + @assert 0.0 < h_inside < 1.0 + end + N = length(parents) + weights = isempty(weights) ? fill(1.0/N, N) : collect(weights ./ sum(weights)) + background = background === nothing ? fill(1.0/K, K) : collect(background ./ sum(background)) + base_token_probs = Vector{Vector{Vector{Float64}}}(undef, N) + L = Int[] + for (m, seq) in enumerate(parents) + push!(L, length(seq)) + prof = Vector{Vector{Float64}}(undef, length(seq)) + for t in 1:length(seq) + λv = α .* background + λv[seq[t]] += β + prof[t] = λv ./ sum(λv) + end + base_token_probs[m] = prof + end + ProfileMixtureEOS(K, parents, weights, base_token_probs, L, background, mode, + float(h_tail), float(h_inside), float(α), float(β)) +end + +@inline function _hazard(M::ProfileMixtureEOS, m::Int, t::Int) + Lm = M.L[m] + if M.mode === :hard + return t <= Lm ? 0.0 : 1.0 + else + return t <= Lm ? M.h_inside : M.h_tail + end +end + +@inline function _logsumexp(v::AbstractVector{<:Real}) + m = maximum(v); !isfinite(m) && return m + s = 0.0 + @inbounds for i in eachindex(v); s += exp(v[i] - m); end + return m + log(s) +end + +function _logpmf_component(M::ProfileMixtureEOS, m::Int, x::Vector{Int}) + n = length(x) + if n == 0 + qend = _hazard(M, m, 1) + return qend > 0.0 ? log(qend) : -Inf + end + lp = 0.0 + @inbounds for t in 1:n + s = 1.0 - _hazard(M, m, t) + p = (t <= M.L[m]) ? M.base_token_probs[m][t][x[t]] : M.background[x[t]] + q = s * p + if q <= 0.0; return -Inf; end + lp += log(q) + end + qend = _hazard(M, m, n + 1) + return qend > 0.0 ? lp + log(qend) : -Inf +end + +function logpmf(M::ProfileMixtureEOS, x::Vector{Int}) + @assert all(1 .<= x .<= M.K) "PMF expects tokens in 1..K_AA" + tmp = similar(M.weights) + @inbounds for m in 1:length(M.parents) + tmp[m] = log(M.weights[m]) + _logpmf_component(M, m, x) + end + return _logsumexp(tmp) +end +pmf(M::ProfileMixtureEOS, x::Vector{Int}) = exp(logpmf(M, x)) + +@inline function _catdraw(rng::AbstractRNG, p::AbstractVector{<:Real}) + r = rand(rng); acc = 0.0 + @inbounds for i in eachindex(p) + acc += p[i] + if r <= acc; return i; end + end + return lastindex(p) +end + +function _sample_from_component(M::ProfileMixtureEOS, m::Int; rng::AbstractRNG) + seq = Int[]; t = 1 + while true + h = _hazard(M, m, t) + if h > 0.0 && rand(rng) < h + return seq + end + a = (t <= M.L[m]) ? _catdraw(rng, M.base_token_probs[m][t]) : _catdraw(rng, M.background) + push!(seq, a); t += 1 + end +end + +function sample(M::ProfileMixtureEOS; rng::AbstractRNG=Random.default_rng(), return_component::Bool=false) + m = _catdraw(rng, M.weights) + seq = _sample_from_component(M, m; rng=rng) + return return_component ? (seq, m) : seq +end +import Random: rand +rand(rng::AbstractRNG, M::ProfileMixtureEOS) = sample(M; rng=rng) +rand(M::ProfileMixtureEOS) = sample(M) + +function build_target_from_abs(; file::AbstractString=joinpath(@__DIR__, "abs.txt"), + maxlines::Int=100, + seed::Int=0, + α=1.0, β=20.0, mode::Symbol=:soft, + h_tail=0.99, h_inside=0.001, + trunc_range::UnitRange{Int}=10:20) + @assert isfile(file) "abs.txt not found at $file" + rng = Random.MersenneTwister(seed) + parents = Vector{Vector{Int}}() + open(file, "r") do io + for (i, line) in enumerate(eachline(io)) + i > maxlines && break + seq = encode_line_AA(line; rng=rng, trunc_range=trunc_range) + if !isempty(seq); push!(parents, seq); end + end + end + @assert !isempty(parents) "No non-empty sequences in first $maxlines lines after filtering." + ProfileMixtureEOS(parents; K=K_AA, α=α, β=β, mode=mode, h_tail=h_tail, h_inside=h_inside) +end + +const PM = build_target_from_abs(file=joinpath(@__DIR__, "abs.txt")) + + diff --git a/src/Flowfusion.jl b/src/Flowfusion.jl index 5dfc5b5..cdfe28c 100644 --- a/src/Flowfusion.jl +++ b/src/Flowfusion.jl @@ -19,7 +19,7 @@ Later: module Flowfusion -using ForwardBackward, OneHotArrays, Adapt, Manifolds, NNlib, LogExpFunctions, Distributions +using ForwardBackward, OneHotArrays, Adapt, Manifolds, NNlib, LogExpFunctions, Distributions, Random include("types.jl") include("mask.jl") @@ -32,6 +32,7 @@ include("batching.jl") include("indel.jl") include("dist_dfm.jl") +include("editflows.jl") export #Processes not in ForwardBackward.jl @@ -39,6 +40,7 @@ export NoisyInterpolatingDiscreteFlow, DoobMatchingFlow, OUFlow, + EditFlow, MaskedState, Guide, tangent_guide, diff --git a/src/editflows.jl b/src/editflows.jl index e69de29..068578b 100644 --- a/src/editflows.jl +++ b/src/editflows.jl @@ -0,0 +1,353 @@ +struct EditFlow <: DiscreteProcess + k::Int # alphabet size (tokens 1..k) + transform::Function # maps unconstrained logits to positive rates + κ::Function # scheduler on [0,1] → [0,1] for bridge keep-probability + dκ::Function # derivative of κ + padding_token::Int # padding token id used in X1 + latent_token::Int # latent placeholder used in Z0 / Zt + bos_token::Int # beginning-of-sequence token id (optional, unused by default) +end + +EditFlow(k; transform = NNlib.softplus, + κ = identity, + dκ = t -> one(eltype(t)), + padding_token::Int = k + 1, + latent_token::Int = k + 2, + bos_token::Int = 0) = + EditFlow(k, transform, κ, dκ, padding_token, latent_token, bos_token) + + +# Random padding of latent tokens to align the lengths of the sequences pairs (z0, z1) +# And afterwards batch the sequences with padding tokens into a single matrix (Z0, Z1) +function align_and_batch(P::EditFlow, + x0s::Vector{<:DiscreteState}, + x1s::Vector{<:DiscreteState}; + rng=Random.default_rng()) + @assert length(x0s) == length(x1s) + B = length(x0s) + ltok = P.latent_token + pad = P.padding_token + + z0s = Vector{Vector{Int}}(undef, B) + z1s = Vector{Vector{Int}}(undef, B) + + @inbounds for b in 1:B + v0 = collect(tensor(x0s[b])) + v1 = collect(tensor(x1s[b])) + if length(v0) < length(v1) + z0 = Vector{Int}(v0) + d = length(v1) - length(v0) + for _ in 1:d + pos = rand(rng, 0:length(z0)) + insert!(z0, pos + 1, ltok) + end + z1 = Vector{Int}(v1) + elseif length(v1) < length(v0) + z1 = Vector{Int}(v1) + d = length(v0) - length(v1) + for _ in 1:d + pos = rand(rng, 0:length(z1)) + insert!(z1, pos + 1, ltok) + end + z0 = Vector{Int}(v0) + else + z0 = Vector{Int}(v0) + z1 = Vector{Int}(v1) + end + z0s[b] = z0 + z1s[b] = z1 + end + + maxlen = maximum(length.(z0s)) + Z0 = fill(Int(pad), maxlen, B) + Z1 = fill(Int(pad), maxlen, B) + @inbounds for b in 1:B + lb = length(z0s[b]) + Z0[1:lb, b] .= z0s[b] + Z1[1:lb, b] .= z1s[b] + end + + return Z0, Z1 +end + +function interpolate_Z_elementwise(P::EditFlow, + Z0::AbstractMatrix{<:Integer}, + Z1::AbstractMatrix{<:Integer}, + ts::AbstractVector) + @assert size(Z0) == size(Z1) + L, B = size(Z1) + @assert length(ts) == B + pad = P.padding_token + + Zt = similar(Z1) + @inbounds for j in 1:B + keep = clamp(P.κ(ts[j]), 0f0, 1f0) + for i in 1:L + z1 = Z1[i, j] + if z1 == pad + Zt[i, j] = pad + else + Zt[i, j] = (rand(Float32) < keep) ? z1 : Z0[i, j] + end + end + end + + ltok = P.latent_token + filtered_cols = [filter(x -> !(x in (ltok, pad)), col) for col in eachcol(Zt)] + Xt= hcat(map(col -> vcat(col, fill(pad, L - length(col))), filtered_cols)...) + + return Zt, Xt +end + +function transition_mask_from_Xt(P::EditFlow, Xt::AbstractMatrix{<:Integer}) + tokens = P.k + pad = P.padding_token + xt_len, B = size(Xt) + T = ones(Float32, 2*tokens + 1, xt_len, B) + for c in 1:B + for i in 1:xt_len + x = Xt[i, c] + @assert x != P.latent_token + if x == pad + T[:, i, c] .= 0 + elseif x == P.bos_token + @assert i == 1 #should only be BOS at position 1 + T[tokens+1:2*tokens+1, i, c] .= 0 + else + # forbid sub-to-current-token only for valid tokens 1..K + if 1 <= x <= tokens + T[tokens + x, i, c] = 0 + end + end + end + end + return T +end + +# Compute the remaining edits for the EditFlow as a Matrix +function remaining_edits(P::EditFlow, Zt::Matrix{Int}, Z1::Matrix{Int}, dense=false) + padding_token = P.padding_token + latent_token = P.latent_token + tokens = P.k + (_, batch_size) = size(Z1) + + filtered_cols = [filter(x -> x != latent_token, col) for col in eachcol(Zt)] + batch_length = maximum(length, filtered_cols) + pos = cumsum((Zt .!= padding_token) .& (Zt .!= latent_token), dims=1) + + #Insert + #inserts = Z1.*(Zt .== latent_token) + inserts = Int64.((Zt .== latent_token) .& (1 .≤ Z1 .≤ tokens)) + insert_edits = zeros(Float32, (tokens, batch_length, batch_size)) + insert_indices = findall(!iszero, inserts) + insert_cols_to_update = pos[insert_indices] + insert_rows_to_update = inserts[insert_indices] + insert_samples_to_update = [idx[2] for idx in insert_indices] + for i in 1:length(insert_rows_to_update) + insert_edits[insert_rows_to_update[i], insert_cols_to_update[i], insert_samples_to_update[i]] += 1 + end + dense_inserts = (insert_rows_to_update, insert_cols_to_update, insert_samples_to_update) + + #Substitution + a = Zt .!= latent_token + b = Z1 .!= latent_token + c = Z1 .!= Zt + subs = Z1.*(a .& b .& c) + sub_edits = zeros(Float32, (tokens, batch_length, batch_size)) + sub_indices = findall(!iszero, subs) + sub_cols_to_update = pos[sub_indices] + sub_rows_to_update = subs[sub_indices] + sub_samples_to_update = [idx[2] for idx in sub_indices] + for i in 1:length(sub_rows_to_update) + sub_edits[sub_rows_to_update[i], sub_cols_to_update[i], sub_samples_to_update[i]] = 1 + end + dense_subs = (sub_rows_to_update .+ tokens, sub_cols_to_update, sub_samples_to_update) + + #Del + dels = Z1 .== latent_token + del_edits = zeros(Float32, (1, batch_length, batch_size)) + del_indices = findall(!iszero, dels) + del_cols_to_update = pos[del_indices] + del_samples_to_update = [idx[2] for idx in del_indices] + for i in 1:length(del_cols_to_update) + del_edits[1, del_cols_to_update[i], del_samples_to_update[i]] = 1 + end + dense_dels = ((2*tokens+1).*ones(Int64, length(del_cols_to_update)), del_cols_to_update, del_samples_to_update) + + if dense == true + return (dense_inserts, dense_subs, dense_dels) + else + return vcat(insert_edits, sub_edits, del_edits) + end + +end + + +@inline function pick_index(w::AbstractVector{<:Real})::Int + # treat negatives as zero; assert we have some mass + cs = cumsum(max.(w, zero(eltype(w)))) + s = cs[end] + @assert isfinite(s) && s > 0 "pick_index: all weights ≤ 0 or non-finite" + u = rand() * s + return searchsortedfirst(cs, u) # 1..length(w) +end + +function step(P::EditFlow, + Xt::DiscreteState{<:AbstractArray{<:Signed}}, + hat, + s1::Real, s2::Real) + + @assert ndims(Xt.state) == 1 "EditFlow.step only supports 1D DiscreteState" + + # Rates + pins, psub, pdel = part_output(P, P.transform(hat)) # (K,n+1,B), (K,n,B), (1,n,B) + ins = Array(pins[:, :, 1]) # (K, n+1) or (K, n) + sub = Array(psub[:, :, 1]) + del = vec(Array(pdel[1, :, 1])) # (n,) <-- fixed + + K, n = size(sub, 1), size(sub, 2) + @assert size(ins, 1) == K + @assert length(del) == n + + # Ensure gaps shape (K, n+1) + ins_gaps = if size(ins, 2) == n + 1 + ins + elseif size(ins, 2) == n + tmp = similar(ins, K, n + 1) + @inbounds for s in 0:n + pos = clamp(s, 1, n) + @views tmp[:, s + 1] .= ins[:, pos] + end + tmp + else + error("EditFlow.step: bad ins size $(size(ins))") + end + + dt = float(s2 - s1) + x = collect(tensor(Xt)) # Vector{Int} + + # Forbid self-substitutions + if n > 0 + current_mask = zeros(eltype(sub), size(sub)) + @inbounds for i in 1:n + tok = x[i] + if 1 ≤ tok ≤ K + current_mask[tok, i] = 1 + end + end + sub .*= (1 .- current_mask) + end + + # Optionally forbid editing BOS explicitly + if n > 0 && x[1] == P.bos_token + sub[:, 1] .= 0 + del[1] = 0 + end + + # ---- site events (delete/sub) ---- + to_delete = falses(n) + sub_to = zeros(Int, n) + @inbounds for i in 1:n + r_del = del[i] + r_sub_total = sum(@view sub[:, i]) + r_tot = r_del + r_sub_total + if r_tot > 0 && rand() < (1 - exp(-dt * r_tot)) + u = rand() * r_tot + if u < r_del + to_delete[i] = true + elseif r_sub_total > 0 + sub_to[i] = pick_index(@view sub[:, i]) + end + end + end + + # ---- gap insertions (≤1 per gap) ---- + ins_tok = fill(0, n + 1) + start_gap = (n > 0 && x[1] == P.bos_token) ? 1 : 0 + @inbounds for s in start_gap:n + r_ins_total = sum(@view ins_gaps[:, s + 1]) + #println("r_ins_total", ins_gaps[:, s + 1]) + if r_ins_total > 0 && rand() < (1 - exp(-dt * r_ins_total)) + ins_tok[s + 1] = pick_index(@view ins_gaps[:, s + 1]) + end + end + + # ---- build new sequence ---- + result = Int[] + if ins_tok[1] != 0; push!(result, ins_tok[1]); end + @inbounds for i in 1:n + if !to_delete[i] + a = (sub_to[i] == 0) ? x[i] : sub_to[i] + push!(result, a) + end + if ins_tok[i + 1] != 0 + push!(result, ins_tok[i + 1]) + end + end + return DiscreteState(Xt.K, result) +end + +function part_output(P::EditFlow, M::AbstractArray) + K = P.k + ins = M[1:K,:,:] + sub = M[K+1:2K,:,:] + del = M[2K+1:2K+1,:,:] + return ins, sub, del +end + + +#= +function edit_loss(P::EditFlow, + M::AbstractArray, + transition_mask::AbstractArray, + edit_multiplier::AbstractArray, + scheduler_scaling; + op_mask=nothing, + eps=1e-8) + R = P.transform(M) + OM = isnothing(op_mask) ? one(eltype(R)) .* ones(eltype(R), size(R)) : op_mask + term1 = sum(transition_mask .* (OM .* R); dims=(1,2)) + scl = reshape(scheduler_scaling, 1, 1, :) + term2 = sum(scl .* edit_multiplier .* log.(R .+ eps); dims=(1,2)) + return mean(term1 .- term2) +end +=# +""" + edit_loss(P::EditFlow, M, transition_mask, edit_multiplier, scheduler_scaling; op_mask=nothing, eps=1e-8) + +Loss matching the reference: mean(sum(transition_mask .* (op_mask .* R)) - sum(scheduler_scaling .* edit_multiplier .* log R)), +where R = transform(M). +Shapes: +- M, transition_mask, edit_multiplier, op_mask: (2K+1, n, B) +- scheduler_scaling: (1, B) or (B,) broadcastable to (1,1,B) +""" +function edit_loss(P::EditFlow, + M, transition_mask, edit_multiplier, scheduler_scaling; + op_mask=nothing, eps=1e-8) + + R = P.transform(M) # must be >= 0 + # (A) Optional op mask to apply symmetrically + OM = isnothing(op_mask) ? one(eltype(R)) : op_mask + + # (B) Sum of valid outgoing rates + term1 = sum(transition_mask .* (OM .* R); dims=(1,2)) + + # (C) Logs only of positive rates (avoid NaN/Inf) + R_logsafe = max.(R, eltype(R)(eps)) # clamp BEFORE log + logR = log.(R_logsafe) + + scl = reshape(scheduler_scaling, 1, 1, :) # (1,1,B) + term2 = sum(scl .* (edit_multiplier .* OM) .* logR; dims=(1,2)) + + return mean(term1 .- term2) +end + +""" +getlmask(P::EditFlow, Xt::AbstractMatrix{<:Integer}) + +Build lmask of shape (xt_length, B) from padded Xt. +""" +function getlmask(P::EditFlow, Xt::AbstractMatrix{<:Integer}) + padding_token = P.padding_token + return Xt .!= padding_token +end \ No newline at end of file diff --git a/src/types.jl b/src/types.jl index e3c30b1..e6a2126 100644 --- a/src/types.jl +++ b/src/types.jl @@ -52,6 +52,9 @@ UState = Union{State,MaskedState, Guide} #This is for all Flow types where the mixture probabilities are directly defined, and the gen is done via probability velocities. abstract type ConvexInterpolatingDiscreteFlow <: DiscreteProcess end #https://arxiv.org/pdf/2407.15595 +# Edit-based discrete processes (insert/substitute/delete) +abstract type DiscreteIndelProcess <: DiscreteProcess end + struct InterpolatingDiscreteFlow <: ConvexInterpolatingDiscreteFlow κ::Function κ̇::Function From e6824014621da8a661275f3a03087240b4e5d9c1 Mon Sep 17 00:00:00 2001 From: Glowster Date: Sat, 18 Oct 2025 11:38:39 +0200 Subject: [PATCH 3/9] saving --- editflow_code/editflowsrun.jl | 2 +- editflow_code/test/runtests.jl | 134 +++++++++++++++++++++++++++++++++ 2 files changed, 135 insertions(+), 1 deletion(-) create mode 100644 editflow_code/test/runtests.jl diff --git a/editflow_code/editflowsrun.jl b/editflow_code/editflowsrun.jl index 0c137bf..5baa179 100644 --- a/editflow_code/editflowsrun.jl +++ b/editflow_code/editflowsrun.jl @@ -164,7 +164,7 @@ function train_editflow!(P::FF.EditFlow, return Functors.fmap(to_cpu, model) end -# Run training + sampling + CE +# PM is the target probability model and K is the alphabet size K = PM.K P = FF.EditFlow(K; bos_token=0) diff --git a/editflow_code/test/runtests.jl b/editflow_code/test/runtests.jl new file mode 100644 index 0000000..ccdff93 --- /dev/null +++ b/editflow_code/test/runtests.jl @@ -0,0 +1,134 @@ +using Pkg +Pkg.activate(joinpath(@__DIR__, "..")) +#Pkg.instantiate() +using Flowfusion +const FF = Flowfusion + +using Test + +@testset "EditFlow remaining_edits, transition mask, remove/pad, loss" begin + + tokens = 21 + pad = 22 + lat = 23 + bos = 0 + P = Flowfusion.EditFlow(tokens; transform=identity, padding_token=pad, latent_token=lat, bos_token=bos=0) + + # ───────────────────────────────────────────────────────────────────── + # remaining_edits: simple 1-column case + Zt = [0; 7; 23; 23; 4; 23; 22;;] + Z1 = [0; 7; 20; 20; 4; 10; 22;;] + expected = zeros(Float32, 2*tokens+1, 4, 1) + expected[20,2,1] = 2 + expected[10,3,1] = 1 + got = FF.remaining_edits(P, Zt, Z1) + + display("HEJ") + display(findall(!iszero, got)) + display(findall(!iszero, expected)) + + display(got[20,2,1]) + display(got[10,3,1]) + display(size(got)) + display(size(expected)) + @test got == expected +#= + # Two-column case with inserts/subs + Zt = [0 0; 7 23; 15 15; 15 15; 23 4; 2 2; 22 22;] + Z1 = [0 0; 7 7; 20 20; 20 20; 5 4; 10 10; 22 22;] + expected = zeros(Float32, 2*tokens+1, 6, 2) + expected[5, 4, 1] = 1 + expected[tokens+10,5,1] = 1 + expected[tokens+10,5,2] = 1 + expected[tokens+20, 4, 1] = 1 + expected[tokens+20, 3, 2] = 1 + expected[tokens+20, 3, 1] = 1 + expected[tokens+20, 2, 2] = 1 + expected[7, 1, 2] = 1 + got = FF.remaining_edits(P, Zt, Z1) + @test got == expected + + # deletions case + Zt = [0 0; 7 7; 20 20; 20 20; 4 4; 19 19; 22 22;] + Z1 = [0 0; 7 7; 23 23; 20 23; 4 4; 23 23; 22 22;] + expected = zeros(Float32, 2*tokens+1, 7, 2) + expected[2*tokens+1,3,1] = 1 + expected[2*tokens+1,6,1] = 1 + expected[2*tokens+1,3,2] = 1 + expected[2*tokens+1,4,2] = 1 + expected[2*tokens+1,6,2] = 1 + got = FF.remaining_edits(P, Zt, Z1) + @test got == expected + + # mixed inserts/subs case + Zt = [0 0; 7 7; 15 15; 15 15; 23 4; 2 2; 22 22;] + Z1 = [0 0; 7 7; 20 20; 20 20; 5 4; 10 10; 22 22;] + expected = zeros(Float32, 2*tokens+1, 7, 2) + expected[5, 4, 1] = 1 + expected[tokens+20,3,1] = 1 + expected[tokens+20,4,1] = 1 + expected[tokens+10,5,1] = 1 + expected[tokens+20,3,2] = 1 + expected[tokens+20,4,2] = 1 + expected[tokens+10,6,2] = 1 + got = FF.remaining_edits(P, Zt, Z1) + @test got == expected + + # ───────────────────────────────────────────────────────────────────── + # transition mask from Xt + Xt = [0 0; 7 7; 20 20; 20 20; 5 4; 10 22; 22 22;] + expected = ones(Float32, 2*tokens+1, size(Xt)...) + # sample 1 (no self-sub mask for BOS=0) + expected[tokens+7,2,1] = 0 + expected[tokens+20,3,1] = 0 + expected[tokens+20,4,1] = 0 + expected[tokens+5,5,1] = 0 + expected[tokens+10,6,1] = 0 + expected[:,7,1] .= 0 + expected[tokens+1:2*tokens+1,1,1] .= 0 + # sample 2 (no self-sub mask for BOS=0) + expected[tokens+7,2,2] = 0 + expected[tokens+20,3,2] = 0 + expected[tokens+20,4,2] = 0 + expected[tokens+4,5,2] = 0 + expected[:,6:7,2] .= 0 + expected[tokens+1:2*tokens+1,1,2] .= 0 + + + got = FF.transition_mask_from_Xt(P, Xt) + + # Display all indices in `got` where the value is zero + zero_indices = findall(x -> x == 0, got) + #@info "Indices in 'got' that are zero:" zero_indices + @test got == expected + =# +#= + # ───────────────────────────────────────────────────────────────────── + # remove_and_pad_concise + Zt = [0 3 2; + 9 23 2; + 23 23 3; + 0 2 23] + expected = [0 3 2; + 9 2 2; + 0 22 3] + got = Flowfusion.remove_and_pad_concise(Zt, P.latent_token, P.padding_token) + @test got == expected + + # ───────────────────────────────────────────────────────────────────── + # loss equivalence under identity transform + edit_multiplier = [0; 2;; 1; 0;;; 1; 0;; 0; 1;;;] # (2,2,2) + transition_mask = [1; 0;; 1; 0;;; 1; 0;; 0; 1;;;] # (2,2,2) + M = [0.1; 0.2;; 0.3; 0.4;;; 0.5; 0.6;; 0.7; 0.8;;;] # (2,2,2) + t = [0.3; 0.7;;] # (1,2) + k(t)=t; dk(t)=1 + scheduler_scaling = dk.(t) ./ (-k.(t) .+ 1) + # manual loss + l = (0.1+0.3+0.5+0.8 - (1/(1-0.3)*(2*log(0.2)+log(0.3)) + 1/(1-0.7)*(log(0.5)+log(0.8))))/2 + got = Flowfusion.edit_loss(P, M, transition_mask, edit_multiplier, scheduler_scaling; op_mask=nothing, eps=0) + @test isapprox(got, l; atol=1e-7, rtol=1e-7) + + =# +end + + From b234ff16cf68b1470fe2f48da82608e5f2dfb0c3 Mon Sep 17 00:00:00 2001 From: Glowster Date: Sat, 18 Oct 2025 12:12:51 +0200 Subject: [PATCH 4/9] saving --- editflow_code/editflowsrun.jl | 3 +-- editflow_code/test/runtests.jl | 28 +++------------------------- src/editflows.jl | 2 +- 3 files changed, 5 insertions(+), 28 deletions(-) diff --git a/editflow_code/editflowsrun.jl b/editflow_code/editflowsrun.jl index 5baa179..059393a 100644 --- a/editflow_code/editflowsrun.jl +++ b/editflow_code/editflowsrun.jl @@ -42,7 +42,7 @@ function make_minibatch(B::Int, P::FF.EditFlow; rng=Random.default_rng()) seq1 = sample(PM; rng=rng) @assert all(1 .<= seq1 .<= K) x1s[b] = FF.DiscreteState(K, seq1) - # x0: uniform tokens with random length in 10:30 (no BOS in x0) + # x0: uniform tokens with random length in 1:10 (no BOS in x0) L0 = rand(rng, 1:10) seq0 = rand(rng, 1:K, L0) x0s[b] = FF.DiscreteState(K, seq0) @@ -140,7 +140,6 @@ function train_editflow!(P::FF.EditFlow, Tmask_d = to_dev(transition_mask) Emult_d = to_dev(edit_multiplier) sched_d = to_dev(reshape(Float32.(scheduler_scaling), 1, 1, :)) - #print("RE???") # 4) Forward + loss + update (on device) loss, grad = Flux.withgradient(model) do m diff --git a/editflow_code/test/runtests.jl b/editflow_code/test/runtests.jl index ccdff93..011c0e8 100644 --- a/editflow_code/test/runtests.jl +++ b/editflow_code/test/runtests.jl @@ -1,9 +1,9 @@ using Pkg Pkg.activate(joinpath(@__DIR__, "..")) -#Pkg.instantiate() +Pkg.instantiate() +Pkg.develop(path=joinpath(@__DIR__, "..", "..")) using Flowfusion const FF = Flowfusion - using Test @testset "EditFlow remaining_edits, transition mask, remove/pad, loss" begin @@ -23,16 +23,8 @@ using Test expected[10,3,1] = 1 got = FF.remaining_edits(P, Zt, Z1) - display("HEJ") - display(findall(!iszero, got)) - display(findall(!iszero, expected)) - - display(got[20,2,1]) - display(got[10,3,1]) - display(size(got)) - display(size(expected)) @test got == expected -#= + # Two-column case with inserts/subs Zt = [0 0; 7 23; 15 15; 15 15; 23 4; 2 2; 22 22;] Z1 = [0 0; 7 7; 20 20; 20 20; 5 4; 10 10; 22 22;] @@ -101,19 +93,6 @@ using Test zero_indices = findall(x -> x == 0, got) #@info "Indices in 'got' that are zero:" zero_indices @test got == expected - =# -#= - # ───────────────────────────────────────────────────────────────────── - # remove_and_pad_concise - Zt = [0 3 2; - 9 23 2; - 23 23 3; - 0 2 23] - expected = [0 3 2; - 9 2 2; - 0 22 3] - got = Flowfusion.remove_and_pad_concise(Zt, P.latent_token, P.padding_token) - @test got == expected # ───────────────────────────────────────────────────────────────────── # loss equivalence under identity transform @@ -128,7 +107,6 @@ using Test got = Flowfusion.edit_loss(P, M, transition_mask, edit_multiplier, scheduler_scaling; op_mask=nothing, eps=0) @test isapprox(got, l; atol=1e-7, rtol=1e-7) - =# end diff --git a/src/editflows.jl b/src/editflows.jl index 068578b..2ab85c1 100644 --- a/src/editflows.jl +++ b/src/editflows.jl @@ -137,7 +137,7 @@ function remaining_edits(P::EditFlow, Zt::Matrix{Int}, Z1::Matrix{Int}, dense=fa #Insert #inserts = Z1.*(Zt .== latent_token) - inserts = Int64.((Zt .== latent_token) .& (1 .≤ Z1 .≤ tokens)) + inserts = Z1 .* Int64.((Zt .== latent_token) .& (1 .≤ Z1 .≤ tokens)) insert_edits = zeros(Float32, (tokens, batch_length, batch_size)) insert_indices = findall(!iszero, inserts) insert_cols_to_update = pos[insert_indices] From 0d125e21aa5228c97173b641da776249d3c3c1c7 Mon Sep 17 00:00:00 2001 From: Glowster Date: Sun, 26 Oct 2025 11:23:57 +0100 Subject: [PATCH 5/9] small fix (nothing to do with performance, just a bug that could creep up that returns wrong dimenional matrix) --- editflow_code/editflowsrun.jl | 8 +++++--- src/editflows.jl | 7 ++++--- 2 files changed, 9 insertions(+), 6 deletions(-) diff --git a/editflow_code/editflowsrun.jl b/editflow_code/editflowsrun.jl index 059393a..1e8a402 100644 --- a/editflow_code/editflowsrun.jl +++ b/editflow_code/editflowsrun.jl @@ -124,7 +124,9 @@ function train_editflow!(P::FF.EditFlow, Z1 = vcat(fill(bos, 1, batch_size), Z1) transition_mask = FF.transition_mask_from_Xt(P, Xt) - edit_multiplier = FF.remaining_edits(P, Zt, Z1) + edit_multiplier = FF.remaining_edits(P, Zt, Z1, Xt) + + @assert size(transition_mask) == size(edit_multiplier) den = 1f0 .- P.κ.(ts) den = max.(den, 1f-6) @@ -171,7 +173,7 @@ P = FF.EditFlow(K; bos_token=0) model = EditFlowModel(; d=128, num_heads=8, nlayers=4, rff_dim=128, cond_dim=128, K=K) # Train; returned model is on CPU -model = train_editflow!(P, model; epochs=2, steps_per_epoch=150, batch_size=256, lr=1f-3) +model = train_editflow!(P, model; epochs=10, steps_per_epoch=150, batch_size=256, lr=1f-3) rng = Random.MersenneTwister(42) println("\n=== True PM samples (20) ===") @@ -183,7 +185,7 @@ end samples = sample_gen_10_strings(P, model; ts=0f0:0.01f0:1f0) -println("\n=== Model samples (10) ===") +println("\n=== Model samples (20) ===") for (i, s) in enumerate(samples) if s isa AbstractString println("[", i, "] ", s) diff --git a/src/editflows.jl b/src/editflows.jl index 2ab85c1..351b705 100644 --- a/src/editflows.jl +++ b/src/editflows.jl @@ -125,14 +125,15 @@ function transition_mask_from_Xt(P::EditFlow, Xt::AbstractMatrix{<:Integer}) end # Compute the remaining edits for the EditFlow as a Matrix -function remaining_edits(P::EditFlow, Zt::Matrix{Int}, Z1::Matrix{Int}, dense=false) +function remaining_edits(P::EditFlow, Zt::Matrix{Int}, Z1::Matrix{Int}, Xt::Matrix{Int}, dense=false) padding_token = P.padding_token latent_token = P.latent_token tokens = P.k (_, batch_size) = size(Z1) - filtered_cols = [filter(x -> x != latent_token, col) for col in eachcol(Zt)] - batch_length = maximum(length, filtered_cols) + #filtered_cols = [filter(x -> x != latent_token, col) for col in eachcol(Zt)] + #batch_length = maximum(length, filtered_cols) + batch_length = size(Xt, 1) pos = cumsum((Zt .!= padding_token) .& (Zt .!= latent_token), dims=1) #Insert From 9459693c6b52cbac17ed6c792941842a0817590f Mon Sep 17 00:00:00 2001 From: Glowster Date: Tue, 28 Oct 2025 21:31:38 +0100 Subject: [PATCH 6/9] WIP so some temporary stuff --- editflow_code/Project.toml | 4 +- editflow_code/analysis_notebook.ipynb | 1377 +++++++++++++++++++ editflow_code/editflowsrun.jl | 3 +- editflow_code/figures/model_vs_true.pdf | Bin 0 -> 93582 bytes editflow_code/gapwise_editflowsrun.jl | 209 +++ editflow_code/gapwise_notebook.ipynb | 1627 +++++++++++++++++++++++ editflow_code/helper_funcs.jl | 104 ++ editflow_code/jack.jl | 200 +++ editflow_code/jackcomparison.jl | 0 editflow_code/test/runtests.jl | 177 ++- src/editflows.jl | 257 +++- 11 files changed, 3946 insertions(+), 12 deletions(-) create mode 100644 editflow_code/analysis_notebook.ipynb create mode 100644 editflow_code/figures/model_vs_true.pdf create mode 100644 editflow_code/gapwise_editflowsrun.jl create mode 100644 editflow_code/gapwise_notebook.ipynb create mode 100644 editflow_code/jack.jl create mode 100644 editflow_code/jackcomparison.jl diff --git a/editflow_code/Project.toml b/editflow_code/Project.toml index 552c322..632a12f 100644 --- a/editflow_code/Project.toml +++ b/editflow_code/Project.toml @@ -17,8 +17,10 @@ OneHotArrays = "0b1bfda6-eb8a-41d2-88d8-f5af5cad476f" Onion = "fdebf6c2-71da-43a1-b539-c3bc3e09c5c6" Optimisers = "3bd65402-5787-11e9-1adc-39752487f4e2" Plots = "91a5bcdd-55d7-5caf-9e0b-520d859cae80" +ProgressMeter = "92933f4c-e287-5a05-a399-4b506db050ca" RandomFeatureMaps = "780baa95-dd42-481b-93db-80fe3d88832c" Revise = "295af30f-e4ad-537b-8983-00126c2a3abe" StatsBase = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91" +StringDistances = "88034a9c-02f8-509d-84a9-84ec65e18404" Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" -cuDNN = "02a925ec-e4fe-4b08-9a7e-0d78e3d38ccd" \ No newline at end of file +cuDNN = "02a925ec-e4fe-4b08-9a7e-0d78e3d38ccd" diff --git a/editflow_code/analysis_notebook.ipynb b/editflow_code/analysis_notebook.ipynb new file mode 100644 index 0000000..03faa2b --- /dev/null +++ b/editflow_code/analysis_notebook.ipynb @@ -0,0 +1,1377 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m\u001b[1m Activating\u001b[22m\u001b[39m project at `~/dev/Flowfusion.jl/editflow_code`\n", + "\u001b[32m\u001b[1m Resolving\u001b[22m\u001b[39m package versions...\n", + "\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `~/dev/Flowfusion.jl/editflow_code/Project.toml`\n", + "\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `~/dev/Flowfusion.jl/editflow_code/Manifest.toml`\n", + "WARNING: redefinition of constant Main.AA20. This may fail, cause incorrect answers, or produce other errors.\n", + "WARNING: redefinition of constant Main.TOK2ID_AA. This may fail, cause incorrect answers, or produce other errors.\n", + "WARNING: redefinition of constant Main.PM. This may fail, cause incorrect answers, or produce other errors.\n" + ] + }, + { + "data": { + "text/plain": [ + "plot_len_dist (generic function with 1 method)" + ] + }, + "execution_count": 74, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using Pkg\n", + "Pkg.activate(@__DIR__)\n", + "#Pkg.instantiate()\n", + "using Revise\n", + "\n", + "using Random\n", + "using Statistics\n", + "using Adapt\n", + "using Functors\n", + "using Flux\n", + "using Onion\n", + "using RandomFeatureMaps\n", + "using Zygote\n", + "\n", + "Pkg.develop(path=joinpath(@__DIR__, \"..\"))\n", + "using Flowfusion\n", + "const FF = Flowfusion\n", + "\n", + "include(joinpath(@__DIR__, \"prob_model.jl\"))\n", + "include(joinpath(@__DIR__, \"helper_funcs.jl\"))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "to_same_device (generic function with 1 method)" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import CUDA\n", + "\n", + "# Device helpers\n", + "const _gpu_enabled = try\n", + " CUDA.has_cuda()\n", + "catch\n", + " false\n", + "end\n", + "\n", + "to_dev(x) = _gpu_enabled ? Adapt.adapt(CUDA.CuArray, x) : x\n", + "to_cpu(x) = _gpu_enabled ? Adapt.adapt(Array, x) : x\n", + "# move x to the same device type as y (Array or CuArray)\n", + "to_same_device(x, y) = (_gpu_enabled && (y isa CUDA.CuArray)) ? Adapt.adapt(CUDA.CuArray, x) : Adapt.adapt(Array, x)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "make_minibatch (generic function with 1 method)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Minibatch builder (uses true PM)\n", + "function make_minibatch(B::Int, P::FF.EditFlow; rng=Random.default_rng())\n", + " K = P.k\n", + " x0s = Vector{FF.DiscreteState}(undef, B)\n", + " x1s = Vector{FF.DiscreteState}(undef, B)\n", + " for b in 1:B\n", + " # x1 from true PM\n", + " seq1 = sample(PM; rng=rng)\n", + " @assert all(1 .<= seq1 .<= K)\n", + " x1s[b] = FF.DiscreteState(K, seq1)\n", + " # x0: uniform tokens with random length in 1:10 (no BOS in x0)\n", + " L0 = rand(rng, 1:10)\n", + " seq0 = rand(rng, 1:K, L0)\n", + " x0s[b] = FF.DiscreteState(K, seq0)\n", + " end\n", + " ts = rand(rng, Float32, B)\n", + " return x0s, x1s, ts\n", + "end\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "EditFlowModel" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Model definition\n", + "struct EditFlowModel{L}\n", + " layers::L\n", + "end\n", + "Flux.@layer EditFlowModel\n", + "\n", + "function EditFlowModel(; d=128, num_heads=8, nlayers=6, rff_dim=128, cond_dim=128, K::Int)\n", + " embedding = Flux.Embedding(K + 2 => d)\n", + " time_embed = Flux.Chain(RandomFourierFeatures(1 => rff_dim, 1.0f0), Dense(rff_dim => cond_dim))\n", + " blocks = [Onion.AdaTransformerBlock(d, cond_dim, num_heads) for _ in 1:nlayers]\n", + " head_combined = Dense(d => 2K + 1, bias=false)\n", + " rope = RoPE(d ÷ num_heads, 4096)\n", + " return EditFlowModel((; embedding, time_embed, blocks, head_combined, rope, K))\n", + "end\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Forward pass\n", + "function (model::EditFlowModel)(t, Xt_ms)\n", + " m = model.layers\n", + " X = FF.tensor(Xt_ms)\n", + " X = ndims(X) == 1 ? reshape(X, :, 1) : X\n", + " L, B = size(X)\n", + "\n", + " pmask = Zygote.@ignore FF.getlmask(Xt_ms)\n", + " Xp = X .+ 1\n", + " H = m.embedding(Xp)\n", + "\n", + " t = ndims(t) == 0 ? fill(Float32(t), B) : Float32.(t)\n", + " cond = m.time_embed(reshape(t, 1, B))\n", + "\n", + " cond = to_same_device(cond, H)\n", + " pmask = Zygote.@ignore to_same_device(pmask, H)\n", + " rope = Zygote.@ignore to_same_device(m.rope[1:L], H)\n", + "\n", + " for blk in m.blocks\n", + " H = blk(H; cond, rope, kpad_mask=pmask)\n", + " end\n", + " return m.head_combined(H)\n", + "end\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "train_editflow! (generic function with 1 method)" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Training (GPU if available)\n", + "function train_editflow!(P::FF.EditFlow,\n", + " model;\n", + " epochs::Int=1,\n", + " steps_per_epoch::Int=100,\n", + " batch_size::Int=64,\n", + " lr::Float32=1f-2,\n", + " seed::Int=42,\n", + " print_every::Int=25)\n", + "\n", + " rng = Random.MersenneTwister(seed)\n", + " Random.seed!(seed)\n", + "\n", + " # Move model to device (GPU if available)\n", + " model = Functors.fmap(to_dev, model)\n", + " opt_state = Flux.setup(Flux.Adam(lr), model)\n", + "\n", + " for epoch in 1:epochs\n", + " for step in 1:steps_per_epoch\n", + "\n", + " # 1) Minibatch Sampling\n", + " x0s, x1s, ts = make_minibatch(batch_size, P; rng=rng)\n", + "\n", + " # 2) Align and batch\n", + " Z0, Z1 = FF.align_and_batch(P, x0s, x1s)\n", + "\n", + " # 3) Interpolate\n", + " Zt, Xt = FF.interpolate_Z_elementwise(P, Z0, Z1, ts)\n", + "\n", + " # 4) Prepend BOS\n", + " bos = P.bos_token\n", + " Zt = vcat(fill(bos, 1, batch_size), Zt)\n", + " Xt = vcat(fill(bos, 1, batch_size), Xt)\n", + " Z1 = vcat(fill(bos, 1, batch_size), Z1)\n", + " \n", + " # 5) Masks and multipliers\n", + " transition_mask = FF.transition_mask_from_Xt(P, Xt)\n", + " edit_multiplier = FF.remaining_edits(P, Zt, Z1, Xt)\n", + " @assert size(transition_mask) == size(edit_multiplier)\n", + "\n", + " # 6) Scheduler scaling\n", + " den = 1f0 .- P.κ.(ts)\n", + " den = max.(den, 1f-6)\n", + " scheduler_scaling = P.dκ.(ts) ./ den\n", + "\n", + " # 7) Masked state\n", + " lmask = Xt .!= P.padding_token\n", + " cmask = trues(size(lmask))\n", + " Xt_ms = FF.MaskedState(FF.DiscreteState(P.k, Xt), cmask, lmask)\n", + "\n", + " ts_d = to_dev(ts)\n", + " Xt_ms_d = to_dev(Xt_ms)\n", + " Tmask_d = to_dev(transition_mask)\n", + " Emult_d = to_dev(edit_multiplier)\n", + " sched_d = to_dev(reshape(Float32.(scheduler_scaling), 1, 1, :))\n", + "\n", + " # 8) Forward + loss + update\n", + " loss, grad = Flux.withgradient(model) do m\n", + " M = m(ts_d, Xt_ms_d)\n", + " l = FF.edit_loss(P, M, Tmask_d, Emult_d, sched_d; eps=1f-8)\n", + " if isnan(l)\n", + " println(\"Maximum element of M: \", maximum(M))\n", + " end\n", + " l\n", + " end\n", + " Flux.update!(opt_state, model, grad[1])\n", + "\n", + " if step % print_every == 0\n", + " @info \"train\" epoch step loss=Float32(loss)\n", + " end\n", + " end\n", + " end\n", + "\n", + " return Functors.fmap(to_cpu, model)\n", + "end\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.689634f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.949148f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.367867f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.82483f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.520725f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.202583f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.252892f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 15.159396f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.860735f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.8605f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.239311f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.785559f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.13742f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.201006f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.12283f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.324005f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.07745f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.980297f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.204556f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.02835f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.109058f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.364738f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.990543f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 17.01241f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.13777f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.440365f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.415945f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.503819f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.38338f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.304304f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.956491f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.750294f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.575756f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.311935f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.014475f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.903141f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.428278f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.780388f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.00268f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.154623f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.851437f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.045534f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.004948f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.882324f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.414518f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.235622f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.864487f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.815882f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.375402f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.58862f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.178719f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.7638f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.780313f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.892445f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.32611f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.11505f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.70185f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 5.3568654f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.881176f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.287842f0\n" + ] + }, + { + "data": { + "text/plain": [ + "EditFlowModel(\n", + " Embedding(22 => 128), \u001b[90m# 2_816 parameters\u001b[39m\n", + " Chain(\n", + " RandomFourierFeatures{Float32, Matrix{Float32}}(Float32[-4.5109034 -3.5286963 … 9.479959 7.8329725]),\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " [\n", + " TransformerBlock(\n", + " Attention(\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " identity,\n", + " identity,\n", + " Onion.var\"#32#34\"(),\n", + " 16,\n", + " 16,\n", + " 8,\n", + " 8,\n", + " ),\n", + " StarGLU(\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(512 => 128; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " NNlib.swish,\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.84128517, 0.91182154, 0.7902106, 0.81407046, 0.88709915, 0.84869576, 0.8111447, 0.9638999, 0.81951916, 0.959513 … 0.97480565, 0.95435977, 0.9466715, 0.9285081, 0.83059996, 0.8631903, 0.8982503, 0.81248, 0.93745804, 0.9293885], Float32[0.13203958, 0.018567402, -0.020930668, -0.065880686, -0.035770215, -0.023243738, 0.13661915, 0.0137710115, -0.09455174, 0.034909584 … -0.0066378885, -0.0024478664, 0.018370626, 0.006716863, -0.04433143, 0.010105384, 0.041511886, 0.06463821, -0.013997877, 0.050439943], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.95347655, 0.85093075, 0.85541403, 0.8679154, 0.85436136, 0.8412683, 0.826746, 0.89666367, 0.8665498, 0.91768646 … 0.9459032, 0.9138322, 0.79719085, 0.85915995, 0.9585866, 0.8430982, 0.89407706, 0.9543368, 0.8155376, 0.95562476], Float32[0.020209653, -0.021680698, 0.0071744197, -0.041343026, 0.048593093, -0.0116557265, 0.09416032, 0.0151361115, -0.067125924, 0.036569614 … 0.0006538567, 0.09313936, 0.018986525, -0.11644367, 0.022701394, -0.024896353, 0.06305788, -0.036191218, 0.06055014, 0.01618962], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " identity,\n", + " ),\n", + " TransformerBlock(\n", + " Attention(\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " identity,\n", + " identity,\n", + " Onion.var\"#32#34\"(),\n", + " 16,\n", + " 16,\n", + " 8,\n", + " 8,\n", + " ),\n", + " StarGLU(\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(512 => 128; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " NNlib.swish,\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9746385, 0.90401894, 0.9233108, 0.90516967, 0.9392885, 0.95880157, 0.9137542, 0.8942627, 0.91990346, 0.9862433 … 0.9012332, 0.9122359, 0.9246821, 0.91831, 0.90074146, 0.91937083, 0.9343478, 0.9342553, 0.92335767, 0.91536856], Float32[-0.011441811, 3.9953837f-5, 0.057703346, -0.06480208, 0.0011973737, -0.028999029, 0.0056339726, 0.0072447304, -0.010037096, 0.033428676 … 0.020015912, 0.017452257, 0.05325796, -0.01191884, 0.01598513, -0.04324265, 0.015074104, 0.033769086, 0.024682254, -0.024697283], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9765863, 0.9458351, 0.93587124, 0.93339974, 0.8989578, 0.9535084, 0.99510795, 0.9719659, 0.9668408, 0.8564658 … 0.9891558, 0.9667731, 0.9314246, 0.83263737, 0.97911185, 0.9124214, 0.91018444, 0.99932754, 0.802342, 0.9956657], Float32[0.017302666, -0.056315612, 0.037888195, -0.06294426, 0.10148297, -0.0010062818, 0.0024953438, 0.044283886, 0.023858724, 0.05449336 … 0.020952262, 0.07595207, 0.057244256, -0.1274221, 0.039070375, 0.02272039, 0.05660025, -0.028933115, 0.07073173, -0.0027376204], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " identity,\n", + " ),\n", + " TransformerBlock(\n", + " Attention(\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " identity,\n", + " identity,\n", + " Onion.var\"#32#34\"(),\n", + " 16,\n", + " 16,\n", + " 8,\n", + " 8,\n", + " ),\n", + " StarGLU(\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(512 => 128; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " NNlib.swish,\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.96034193, 1.0159357, 0.9689168, 0.9651938, 0.9500553, 0.90168905, 0.83910173, 0.9460418, 0.9834187, 0.94236785 … 0.9693384, 0.9697664, 0.9737863, 0.9381034, 0.86150926, 0.9611176, 0.93992716, 0.9402713, 0.89132005, 1.006154], Float32[-0.01447692, 0.011735456, -0.0020311004, -0.034760233, -0.05172142, 0.057911456, 0.06251694, -0.018139904, -0.047031887, 0.003290893 … -0.01567474, 0.010805595, -0.015121574, -0.023687487, -0.028759452, -0.029005336, 0.05817738, -0.028409438, 0.04294521, -0.004147324], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9365266, 0.9492814, 0.9448586, 0.96640795, 0.99485415, 1.0097846, 0.9969547, 0.90934587, 1.0050943, 0.9689348 … 1.0519694, 0.99240464, 0.97498804, 0.9176811, 0.97813183, 0.97207797, 0.9781743, 1.0189404, 0.9108524, 0.9999426], Float32[0.0152735, -0.09397738, 0.026495976, -0.06649545, 0.05174599, 0.016729476, -0.015519516, 0.03077308, 0.02534834, 0.031068088 … 0.024515463, 0.029270023, 0.024118535, -0.12969638, 0.020150084, 0.034348086, 0.058396515, -0.031155355, 0.07536059, -0.020158395], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " identity,\n", + " ),\n", + " TransformerBlock(\n", + " Attention(\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " identity,\n", + " identity,\n", + " Onion.var\"#32#34\"(),\n", + " 16,\n", + " 16,\n", + " 8,\n", + " 8,\n", + " ),\n", + " StarGLU(\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(512 => 128; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " NNlib.swish,\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9972363, 0.97399354, 0.8619699, 0.961095, 0.9606036, 0.9139958, 0.9732229, 0.9583855, 1.0531006, 0.9394396 … 0.9756284, 0.9310381, 0.97951865, 0.92094326, 0.99687564, 0.9567006, 0.9752043, 0.95546454, 0.9057552, 0.98454964], Float32[-0.029275956, 0.0912551, -0.08796287, 0.028532406, 0.039656058, 0.03142834, 0.058119882, -0.0062778257, -0.072126254, 0.012900912 … -0.028987817, 0.04767919, -0.031961385, -0.029327428, 0.0059409034, -0.025743894, 0.004865544, -0.007499804, -0.0074433223, -0.033123918], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9899853, 1.0113794, 1.0489874, 0.9276706, 1.0521827, 1.0159994, 1.0239544, 1.0025413, 0.93732625, 1.038729 … 1.0678216, 0.930407, 0.9801097, 0.76677334, 0.94644517, 0.9789134, 0.98342764, 1.0859528, 0.91786045, 1.0444598], Float32[0.005111467, -0.05680973, -0.033371042, -0.0843999, 0.08355269, 0.021003177, -0.013964859, 0.007897407, 0.036769442, 0.05594361 … 0.012858942, 0.022676993, 0.057679325, -0.21971306, 0.023857664, 0.030711865, 0.11079519, -0.04627623, 0.107559755, -0.037148476], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " identity,\n", + " ),\n", + " ],\n", + " Dense(128 => 41; bias=false), \u001b[90m# 5_248 parameters\u001b[39m\n", + " RoPE{Matrix{Float32}}(Float32[1.0 0.5403023 … -0.87528455 -0.065975994; 1.0 0.95041525 … 0.9552474 0.8159282; … ; 1.0 0.9999995 … -0.57972294 -0.5789079; 1.0 0.99999994 … 0.2726629 0.27235872], Float32[0.0 0.84147096 … -0.48360822 -0.9978212; 0.0 0.3109836 … 0.29580808 0.5781532; … ; 0.0 0.0009999999 … -0.8148137 -0.8153929; 0.0 0.0003162278 … 0.9621096 0.9621958]),\n", + " 20,\n", + ") \u001b[90m # Total: 80 trainable arrays, \u001b[39m1_339_392 parameters,\n", + "\u001b[90m # plus 3 non-trainable, 65_600 parameters, summarysize \u001b[39m5.364 MiB." + ] + }, + "execution_count": 70, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Init process and model\n", + "K = PM.K\n", + "P = FF.EditFlow_cubic(K,; bos_token=0)\n", + "model = EditFlowModel(; d=128, num_heads=8, nlayers=4, rff_dim=128, cond_dim=128, K=K)\n", + "nothing" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "model = train_editflow!(P, model; epochs=10, steps_per_epoch=150, batch_size=256, lr=3f-4)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Sampling and Levenshtein plot\n", + "using Random\n", + "n = 500\n", + "# 100 model samples (final states → strings)\n", + "model_samples_any = sample_gen_n(P, model; n=n, ts=0f0:0.01f0:1f0, rng=Random.MersenneTwister(42))\n", + "model_final_states = map(final_state_from_gen, model_samples_any)\n", + "model_strings = [state_to_PM_string(P, s) for s in model_final_states]\n", + "\n", + "# Build training strings from PM parents (the data PM was built on)\n", + "train_states = [FF.DiscreteState(P.k, sample(PM; rng=Random.MersenneTwister(1000+i))) for i in 1:n]\n", + "train_strings = [state_to_PM_string(P, s) for s in train_states]\n", + "\n", + "# Independent validation strings sampled from PM\n", + "val_states = [FF.DiscreteState(P.k, sample(PM; rng=Random.MersenneTwister(1000+i+2*n))) for i in 1:n]\n", + "val_strings = [state_to_PM_string(P, s) for s in val_states]\n", + "val_strings = [s for s in val_strings if !(s in train_strings)]\n", + "\n", + "# Plot normalized Levenshtein vs. training set (distinct val/train)\n", + "plt = plot_lev_dist(\"model_vs_true\", val_strings, model_strings, train_strings; title=\"Model vs True (normalized Levenshtein)\")\n", + "display(plt)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "pAA = plot_AA_dist(\"model_vs_true_AA\", val_strings, model_strings; title=\"AA frequency: Natural vs Generated\")\n", + "display(pAA)\n", + "\n", + "pLen = plot_len_dist(\"model_vs_true_len\", val_strings, model_strings; title=\"Length distribution: Natural vs Generated\")\n", + "display(pLen)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Natural 'A' frequency: 0.04931058658565085\n" + ] + } + ], + "source": [ + "println(\"Natural 'A' frequency: \", (isdefined(Main, :val_strings) ? sum(count(==('A'), s) for s in val_strings) / sum(length.(val_strings)) : sum(count(==('A'), s) for s in val_strings) / sum(length.(val_strings))))" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Natural 'A' frequency: 0.038456812876274726\n" + ] + } + ], + "source": [ + "println(\"Natural 'A' frequency: \", (isdefined(Main, :model_strings) ? sum(count(==('A'), s) for s in model_strings) / sum(length.(model_strings)) : sum(count(==('A'), s) for s in model_strings) / sum(length.(model_strings))))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Julia 1.11.6", + "language": "julia", + "name": "julia-1.11" + }, + "language_info": { + "file_extension": ".jl", + "mimetype": "application/julia", + "name": "julia", + "version": "1.11.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/editflow_code/editflowsrun.jl b/editflow_code/editflowsrun.jl index 1e8a402..93fe021 100644 --- a/editflow_code/editflowsrun.jl +++ b/editflow_code/editflowsrun.jl @@ -167,6 +167,7 @@ end # PM is the target probability model and K is the alphabet size K = PM.K +println("K: ", K) P = FF.EditFlow(K; bos_token=0) @@ -195,4 +196,4 @@ for (i, s) in enumerate(samples) else println("[", i, "] (raw) ", s) end -end \ No newline at end of file +end diff --git a/editflow_code/figures/model_vs_true.pdf b/editflow_code/figures/model_vs_true.pdf new file mode 100644 index 0000000000000000000000000000000000000000..6f4f1a7a3d53e7c888d4cc28047bb543bb1aec24 GIT binary patch literal 93582 zcmd6w?~ZN9aoxYqQ_L3uwt)=i{F}KG2m%}_Vr(a{Ee3D^K_6)GlA>@)#+O&Ll9vpS zS4bWtzqM9X@80{6*NRD=Z3hu&-QL|@Rb5^Gy7$>X`MY2I^4}dE&UZigzyIfd{qMWO z{p0;t|M>g6pZ@gjgP*^B{qei6-roP&hkx_YpBMc6t1o}?@w?aefA))ie|$V%4v)uI zhZp@n9{9VrUw!h2-@ZsAcW*xb5_~dV1`uu%GeAEIjbHuY%XjyW({vhb z{j_K4M-O)&{LSZ|e0~4xi)Q)F)bV-h_@7^Y`PsYQ-5-v3AN=z3H}77*{opS@`uSh| z)qi^Z$6vhu?N^_?R=2O;A+9g(9{qox`v1go{c|y|S+1!O=Wky_c(MMg*I$42hqu3l z_n-ds{)1nBMGJp0#|QuMkMBPG=$#fo3-sYfkAC9kf61^P{Ptu1R}X#o(eX0={o(QD z)#K^qnD&A4+~N4VJb3nl^<04-Zj5(u`$6-l?e9K*hcvzvHG==`Z~yW4uYW6Q1@$lg z<@G0@fBYZ5`s4ktAEEB)@$vrr`1l)1|I2r9{Pq14|NJXGS`rd&364s?`S@^rHDpt8FKRBAmj|p*uT;UksCn-$xUmk0mIIo6IWL>P@SD4RsChm< zym~cJ6TA~O$J6u5Fc#j4n$zRq;c{7IQ+O|Go-V7EIt70#HHY>Ic3zWHSls8o#+m;A zZl)iJjBoQx=T{Fea+%+G*d4Gt=>XW6EvVv)XKl zT#3N4>j+_A9kg#xPY-9=*;kJbFOB&7a=brX9xku$zfsHM^Zn`k@cejRe;*%+??=nw z;c!-q`aC|63b=*QjxP_Vr~Ay4ziBx>Jim0y>EU=@`kXYwDWm1@o+l_2q)*f4(Za*b z5A%e(=ZEv7xH~xA{Jw?t`9R9-f}Wsrx)*2$z^S+D%vyaq*M z(x)}XqeU-jqE?v$u^p?|ZAa=SLusgeS%*AggPN?N=@3xAQk)tyysQ}e=B{Dsj(SQ( z3=`ov!i9d9y*ezXB&ok;{cto!$E%izX zD%|iQHW<^V&FfeFT9<0f(xqazbV(8=f$g@Zhv&s29WZw?xY5r7L%eA-EqaiCO=pc+ zDmC-BlU+JKo*y3D?S650e5ByxRkar`hzRV4>){PV2!42%7(&?zdZ+b#A&590Nb?;I z0^bZc=tp;Wcmv&+hZzb+q|um=NA^C(iGzg`@#pb?wmX!2db}4P5>s54HdK*EPY)Ni z#ep8k6RAGBALf^SXZ@qv0$x2$ZR~`L+u}=6A_ysJ2(FU#0~f z4v>ZhGT$TY0xl0vilG}m$@PTY1EgUm5DERBZR%M4OhIJZTP<7E`%a|6?%0ON`_U#H z=cYEqZ}=!t1e_mU&QlwrkO+^qR;L91g4)_A{jVmF3#508P&5;Zs753Urhl{NuK~ zqvnH(0JUM^prYCc{8)P2X!HT)W;?RsL?@bHz=l=7K+h-H@Tg}*?=>b{QM)=j<;erQ zcsFQzM>K4WkT#%shck;=ZS=5}J~LQ>X1AbA%GFOQ*X$~hOj?%t0*YPKvD%(=bO2zD z)JEyb{SIO`s(_V<8c&+BQ`T}4eYOrx(N9`|h5{FMR{3Q?ZEXAO2Ib%yI)3PW6+Z|v zCM%%eAoB%$b9a)acvaoTGO~3?Kf)I@v&IY<^92?y={M+X{|ZYh{xo0Mwc+CQf`w#D z#HgLvC6Dx|SX5Ak%Ralom_BWZ|I$yIDLY+bM){lFiXSA3cpEu{!>Qu%>W8W^eT^9~ z<_j!Z+;5@NV>S;He>)kx6ILU22==Q^h=}*SstySXYX2*ZuZK5q*ZARdB)erHP%0Vh z6AO!N3lzbDWw2F(d`3$)unhL;n7GddTR?#nKn7b-V;r2rX>wZX=_2#$~`eL50WH#D7okjF!IvNQ~~+5`r> zfi~FHuMKvM8KYeD1%zGI=TfnQFv19c4Yuf13`Bh(>`E2bhBDaVZ)nC|1{&km5*!~<68aN@McVwN=7;J1*jj=LIJAHK6w~ys6b`P zU>6wkrLAa5zc$zzvw4{K(|mz#uz5(qtlp2# z+8D)d8*D_uo~@06@Xpa_8+sU3{ienY81n_jV5c9m7M&imd6@Xy$zY$Q6li&=lwkZI z8g_BTg{Tmhr(v|0z25XX0~7xe4*rKhvN+OT(ANjLDfMV@Cc-E?SSWeY1=^rA)sC7 z_<=onA;9hU=gf?%0$0FuzL176rZdzA6#*2~*1%S&ADLnWJRWmwH0EPVXV+;y_79JG zPYRG<103*39PCD^BXsKY)KQbuz=jp@=+Srt2GcMKqAK7KL;--rIAWK8E+FhGg|9Yv z_k#|2#07B^>QBJaV6dCETzZns90-OqAY&pmjv;HlfMORBRvX5Z2`bon+hI?w~g}n#4606F27s%!0Cy;xCf$T0yWr9>e?5?n?3#|H<9?sDNsz56%q;RRY zD>z1$JY$+wH@p-qo7Gfppo!ecW?k4Pa@A#XFBeilxT{iZL20$}u6lR_`{7;8(B+Bq z0`#)N5M5@FFEkWTXj$%EP$7z4e}nRq4IMIczX~S=Rc~_iTJr^bb9Z^7f@sAe47qUM z2OU8kjspZ0bZ5*0Jzv4lQvI6Fj9EO){As?hTVaT%h!Lh1dU+!Kh>=xfE2z?dU4Mfy zecBv`R6nV(BGej_MJBRsb}I~#DEQZEyPy_Mz|!yX>=ZL&7U=m3hL-e$zlbSgvZ2hw z#NSR~$mI!cQJYq&C-TgO7XZ=7P^l*u6icNFG|vTV`O|NxhR1A`@_dU**|ByTX|e5k zWcBO;N~H?)d<9FT(r>6#oOQOv%%9df><*Q}vNL0rgE6W3kEMFX|JqQJEL{qW>C=|w zPrpT_JZ7s@*yVp!MYtd)6^ac7s5>nEC@OeEkuqJlzbDZ16)g33zd>ilY?Ye$+exK- zF2PMF#GvYyO4hjFK$WbYRRQ5hf};~4r7%`tv>x%fueOlA=7XstoeuYFL}`&#(ztBU z3rFIr9c3DhHx@|5_I$rQY}g~|AY~ahs43dT&>ty2L6OccbaCoP^#@r7N@j*leV$#T z`A4?x67 zX*(w~m^3LJ|BHRcpplyda2!F@M`+z`Clv?*Tp3Us9ta&HBqua2z!N^k2pq(q))Q$) zV^ON7R~NAt#C(NtSF(9nWkjffegHIy0H)^NheNm{ToBF%sLch^Zo}q2sUNiq_jZJ!F6g6b2)$w2`xL zOJS@lF)>FxwXOwvT?3n#vlVHL#=2I|Ue|)XuFNSN%(_AiDmB&>C>xn|g>Xu^V_g+i zV-l+kvZi${F=kz7neMf&glr{c+Z#opEHgqUb|Mraa74<^;*Nw#l!}2W!56>~``Ei6 z+eU5fM_lS-Mh$ts=YNPqGn@Zrg$X5D{c3TAjy~Qt3P72e;mAG<^i%~QgY5<&Y8Htm zBO@01Gi#bHoO)TXtn?&9u2mu$9a7Mv&fytVhw%l*^l5Xb!y9kvH~8_8lx4}WGMoQq zKuJUnOD%|syt(^a*zu5&;R^Ir1w%%X>6Uaqn1aJoc zwh6QYwP+|A(GA!-c56id9cQA7d64M`Zb2(T^g2@=%S!WeSf zDa}6Wf;!|9t@?Tqkn$c}Q(54};fic>y@s3URLhG^E{J2t0}uf>!MQlpZJd>1Nvz&# z;}08mAJ_$yL#wu4JB@N4&Ln6!lY*W|^FbkGv!65tfxvJW&`IhmJ+hSHBI+pn1VEvr zRt^$iS0PJ+gaYkM0-H20onsf*Xpojh84YQ*qufE-Gkv@pG(7;*HAs7gMho9<2@xR8 zTK!BkgtTpPjs=>uz(EY@_2WXC5yD5)2w1A;2DZjS09hjsBZVV?Q(FL{lvWdAj^&1M zto>MS@z|?>tHmKewGc+hmOf(9R7eh$=hBDxW)WyJSok&! zy%G^y+n32oDwGja+d-Hp8HUFDU+mb#D0X2~uC8j6`6?L51F{_y{rKY6MU> zvjC_p0I!@jK~8$Tk!a-{0VvPKFbn`--9_Eg-(Cu1TgO!wuKG$3%Jda1dh6LW zS|0U4ix@mm^VZ{5>fN)hVL!Z+AY!ds5ON~XR%x=XZ6(1b>(r{^*?2)lN;?|YXh@0h zb-3pfmv2EB7hSeJVM3J%;X({`Gxr+SQtTrXuDejHgibcFE2;J6Si8OFXWTbGa!Zt$PhEU&Nh$6cI7z(2{F(3KF=i0BIW2 z1{)RBqh^&+vEQCPr1_c|!aqP-+O#g|CkHJq6lyajWnzGeD$E!0p`JbcPNB9gDaH5r zUG#!&D0JIN@k86%z}|W3x<)TfRo%>^n!%ZmdP@UTm5>Z#H(P7FE+&|S-7 zp>-TRTF87H3ER+7tZ`f{Q_sY>oHq4AZR+)$R92>*Y7f#yg5F9RyUhEEQ*emuZ3}hi zezq-SlOMM0(cwS4F{ZvioBDz=_3CDunQbe6vEVWFOg4acbm-e{Y(6{mnEDcFO#P5= zOg)?_aBfpC$c!=djLBIU8ziP)tlELd)N6Xj=8oG>2w#~3PpAz#)6b?JC@U3HuLWd+ zHudxLdzpF)pUNXU0HZcZ5;4L{%8DdXL<2fQIOXJaY3w4D^LPC?2+#KBQqge~w@&jc zdvQu7fO{ols|}c~M!}1k;Mi&^hFMF=6Hoj=4R*b^+B2LzMV(L7EXaymwJA&B$+HQm zN#G|ss-h@Cs+OoqWfsL~QR|@IYI=^JB=A<#2ria*t1&hSPBs*?dJ_^yq5Pt*65kVK zcf_X_{0objtyZA7TET2Jx}`={H1QCT47A|Bm}~%zNmXoVBZ%`B%~mUsW~&YPW~2K^OU#=63`^}WRC)2R|-WV%;$LOBGl3Vl?BNf-)3pDw!zDr`g|I0t@!Aqj0l zN-8epM_5;tU*ciBJ``tCa#!#MP-8-t+_^wS2VFy)XLsMRzfLCgFRHT1`l#@RrNdRrFB?hhiQrcml-v^q3xc!VJon0 z-kyv|92^VA+-&g<79b1yss$J6>UD_1p7G-?;l+_Y37_g{C+b?ZuUISz83U&9MWGCT zNcvm=2(b#M$jfOR;zmsK*CZKNW@|?m_XpD3*e1=|W zI7FNd;M9-RL`NV^_ftfp_64gWrJ&MpK&%(eblhBvgj@l(X-iw)eWIU^?O7Xp2&RDL z+E1{GWX67iR~?pkdszutKC+_77zMTZ>Z)5QuXTB+{d9iBRlrEu$%18!&Xmevca8L@ z>|`|}E$rl(*XdOTwVmKfEf6OTWR1?$--cmSn-`+n;yKDr>gPFi5{4J#dT)WUlLgyO z@*4sRX{VshlIzh8)P@e>6cV7-c2d-&oNGHNsBFh;C&IO94Me!h%H76xvp(2PwiwNS z1Iu);b=5|}h*?Ts+?@-S=Qtx_*`EzW(^c&2hd0pMaI_Lqv9t_J)qP3YCgAU1kc`Tl_v-CNwCqGozFr!@Rj%-6EemH)$rf345Nt!4*hzmpFO^T&207E zKnrSc7rE^eyPTUU>xp3j8gJ+FKGRB(8GzxVQNwc;aqD9nI)_O+w zh*c|?KWlHItqz_WRPfx;E?3=BPj>JuS;*{UyRv8lgbtihwTUh4Zj~fkqz;}NSlp3- z+}0FEhNSm<3UxbjF#Xz22qhVOm7(+Y;8g{wHts|0i9!734({taw z1i_^{WkBs61DjXf)*A=x=b+&o3&uMFlDavI(0g>TPcospj2#`)@uJ=nOhLtM=p@s( zcclENbTHnrKzql)L7ERB)@UqB^=t!Ju)QNt)t-1qs8K`&qc-r+s%$9R4K5UGw|9g` z71yebpB%7%iFYh9#yie3ZST1G$;BV(Cq22~MMBWOTpaYiA1=NP8Az;uh5MGjZyNT; zuN6~nQaKLSiTdq8M}C)>U#$%tfw!k){6cZ)c;62c|EStAew#RSyzi%pe_T59E5yAn zs~;u4@y}**-a@R&ja-5}9pfu)4B~I14DR(hr{hSA5P=s`eecG96K^W}sumZrst;p2 zpUY_cFG+Uh@!w>DJk1;1X>pZ+w`SAFUV&2%%3|0_>UOd$&hmmx0sW~gG;K9nvhRr> z<_RL$)vw4h9)TLyjY0fP=mMvi6^{aUm}gq@ch4F`rHQ;eeK^E&mg~`YJsB&WdGa^2 z`ubuJ(s9;RQp6B2t4HI+N`JQ$gG@p7Y1%wmQ9bd~R{qusV~@mgarTKwxggF$7*P~3 zf^m{xke^(mesY(iD&)?}wXQ=7^|~PbrmWKX1i}YL*X!?Er9#%u>O)UQm>JC)UGtQ# zbJQnIOAF)hs%-b6q`|w#87+VJJVDlVX$XC4AJ%Br^_d@q*ygTuonBNbqcw0sowRiw zL^2*-ufKcNv{*Z@v6)Ww6;<5J!YS6kaC0KO5kafNKl&)vAqI%+I zCtc?-k3elG3>kSNy{2G;VN(FXD%WJW@^_0gC`+6^z4#f;YEko)!f?crYo0=;fd1-J3R9z5VP<}K=`P%r!tk8b!idrI0(&hAXM+mxyj=Bn&zcr1 zO!cY7&uCGS%rg{*awX^dHk-`Gp$(iyiX76ychoO`w-ke-FzM3@}Pd#Ds9M2r)AwwmsBJQ zkJ+Hbn>N^mmg+a?WIYxhid{3bmrAjZQ5*Q8T7XKq+EWl8Tab;C^X)vmf$qCow(k_E zw*=c;NqZo6O&1MX)qpw;h#D4X9cgIwt$wZAHD=Tv2kDf{`vd<}>SPGevFzx_KaMRy zn?dPF!J;Mo2A!qa-sLr47*eSr?ADfG7?t3%C2$ZF`Nx*PqN?N=H7qdLOV<*^74G{D6&`-lszWNSFIiM=}0RJX<9Iqy{6*5-8dVdOn2Vvqxz}fwd|w4{*UclHf`9Jf`C9>{;d`(JGM4BfnvU z63Cd#?yw|IrkrRA>hQ^#mBu7Kr(Z$O2fMhK=oFj*FdSZY=WD(dC5Y;1deLHF(iVvC zBDm4U@+B6yC(#nbk~e5}tBoTU*sXrP(zJ}peG|k~^BHuaB@xobI-t}7olIFwDZWM( zXyZ_jezRumw2hMq=nY{qfKIduCSf`$CzhsQQBgR(J*-tJz@A-_up^fp5o`J#`4(18 zy%Vh?H-cHl%vZpkjYzcHtP@K=CsRG9fe)KCA4^T5RkTEx2Ax30Y#y9>6tHI_(K;#5 zu3{^RRzazc#-x%^#a39;6kLKqUkr-fK#_(4PCt=tF##D&=l-MOCn%DcA|9!-FK%gfgeJ* zYF+SbL{=D=EH6f>VAGG;jRJ?Ag4P8dM)kAA#CD8p{la+IV59AXKKg1JR)cUTfNToO zz(R8{p&P(hJ}RYBQpfVNu^sg&YQ_Q80KQz`kjqe<6f%eun1n*xS5stL=+KQlq6rA2 zTn^&k6(tW8|C)e(U`tETOMyhgFdxLHEx##U&@wT*isl%GEu&#HJx4CNS?D9H>^w~` zT1rhJjrgx1JmA69k021T8C#Hl)lW2KB{e(~V-kl*)+y-u zo|;8Z!IHsb5(rh?4~Ibg9v)i1`j(+7oWAy{Zd=2d_aHjSPMJJFki-#3| z%vbD|h2~MTuvCLF@vzoRS?Gi(WuY6Cg|5&g7CQZE3!5dz6ie)&h288*r?b^22Q6JF z%bpCjEOfwNx1lX``VBgPI<1YiulU7)|`Cjcn3^L_uPG z-B6>ISK9oNF^-mDm|pcxKT1Y5cAiQE(9&uO7dpWR1jx)YJz}@>Ruv40@U#{JusgR= z;6#LuJS3(B8N>j3lw%`A!G6`&CK@Rbdgmc}SW3i!nSlr9v+8Nd#4efNP=%eglROCW zmmC#C!nu3X)~Ix{no zVrjFzvS6hi*Jz(ZndF#uv`5~<$xZOqdUh{3kbW~eQtwyiUtB*7_gX#fnYbPATMM!o;719 zW67q|AqtY#Nfd8=5SkZ!(~uvdf{~?-(3- z@f_RHBpLAaYm7JlSZ!1UL{xR-MHJEv(WuKY1w0x30y*7)lAgQKE;UIma_F3fw|w!# ztRU$h#0Rou1t~13JPX@8#o+21Jm78sPY}X&WMWx9NpdUO*=4 zb(=1l@#eI|%oB)`>B($pV?j`aK&D6W>rtjhlzJ3*Av*-bjtS~t3seN!5K38*(8*6C z+GWC$ZoBXk0;0m3w!k-c*a*l?llR&|zqzQbhqM?8IS|d)-xvrbjfL|5BFzW?tF8YQa*U)kmuY zyXxaC(Q5|DKDH9D5nj!^lLdhWom!C+Vdzjm?~sBlc|rD;A`CrDK}IRBAPYndEr>c1 z2^#rt3yQo>*|1*k=U&f|DhV#qf)e7gnP2r+e|(UZj);TAhU}mJFp-Km0oE>LS+J=( zkW!iq7lzkpJc_##!5;LDOqmdSPQQDAbJgFDWvn+Mi-4p4#zHD^D}-g#uf3oRV%QF# zShnO=V%#ZI@jL!$P#z1JqEe*APu)Omv>A zsmOI3x6q}rm>$R`&XU#;6qWI0BNs$3@kH7LJjyUwMzO>&eiZUW4O3to3NXEmXFbTX4!VqwIE>?{8$Q5ewX%44_L4Xa-aD;`}dj>|xVM17Jc^I6*bH?%mXf+lRg zC}mp!^e8+KoHIohO$_TTZ`^{pje2Nx)4~~xPDw2RiL zMw$EV+Oyl9IcsF~#5Y_^Y#i+1YP(SJ+M~a5{!2+r-I{r%= z`z5yM*^PO{d?38Ba&0tXk-$zH=)jK{D0?L4#CWm{=%5n$U}%I(%%*=^%o5a^P!kyK zls0uXw8eag0Eua9VO1$8Y%y`HuO1$BSgCeY-p})E3CMWD=!fPT&j*k3ivBHbdiGIm zidS&2-)KT%5vopx20l;&lSqiLacT09M3t01NE{T?H>xWE17nHt?dprT5f?66=E#Am zekILmQ|1j)E03|b-AdG@dHBZ!1`Z-lB&CpZ$m1_lkYOJUI$KJJ&ix1w8Pj6I|?myq*V%{fF*qw4l^>#ul%~^4bsR+ zOB|;a$*N>J`sxaXq?3^wHUEW+s_MJYoROQOnctnFfdfBNDm8*cGz6hHhD#^re7DCt zb%V#wspqdS;j4Eh?G_&{1lO0JA@z^`B?2X%W}lX*^}DW8QwyGjpbVxX<8Dpii-o`p ztCf{kU!qZsT&NeKFbkp3uZm_`2>at2xfY`44bsS=s#^)*phEd@LfUWy)&^*KwbN1Q z4z-LTN}h$;F7nt8ghg}87hu&OrCh|a{P3%+WKihP@qM@QYN$pYeY0}fh#I-j;J+{% z5yynw)mIzQ83P<@WaQx={>!{Unm1H+YiM5j7DqMm%`;E;Zs>fy#hXm&fmDG`S zC<9L_el_A~$2Pn$OR9)QeR+0l4n|f%z0_X^BvKt)VUzb1f{_`b zQPxGRuF>n4G%*HRC$QW!MNCPHkrhOcihHApf6Z)vs0-iXFo>~OB}uDWp*gLvqE^yb z`A)XK@?Iy*p4Z!dMaNz-6j#sDM*WH<+9zQUzDgKvX$!O9iHYj@E$-*{iCI`m9ipQh zXcA0hDGRgnXmFImf4uXcmMu56Q|S`Z?yu)vb(NNfX{@Yck;bd}c3L@C21K;|H{W(s zr9hYhgCcZcQbA#rY53}g)tXv_R8tj586#Sitx$4fFBDR%)5y`vF3Yp{8nsdiNl2)4 zp^>ZRORGXcwIWmb7S|HhN{lW{5m#kVLLiw$5~z$!vLXY*fr}DfQB9s>ld7jllw?j= zJsCk4QPi8aw#l1RQW0_id}_5(R9}U07&)w&TAk^ZArrp}dfTjtN{UjW)x~ci`z;kU zbr1~3eX00q8tsBKa$!7V*1;l{QFQ&4vBU%Qz;Mh=!@G(OT~Lvkmx$)rdDi_s!9k=^AI=p`rF<30NMOY&K%r?Dp$aSeblHmw)?RXiGSi* zt&*#I;@I(n3-gU)^db+nqG@!}NH(BYY{gI34;fG!a_NKaO9iPlFZp*XHD!(Dn^tOd zN-V6r8D#zUe%L7n&}W&=UZtc*Qhg~$r*s2b?@@4yG4^sB+?Gdm6x|=(Vp2->4gGt* zE%y9-Std#bWow`v%S4{7!*?`5??!;6dC~{#I9N6S+^<>4lpC?eDn=*_s8*bFMUdXb zDS*hjU{tCcBKzR@df+nKs;tNzFTxB)f3j0+v@7hg0m7z!pgp9R8+}u`N7~4S_HN{6 z6lKfSWVn*cU@V>$A1riSjQbK1RXF3lsv=A2Jv$jxDJRUT?<~*V78T8w@Ys?5lqfl- z*&o7V`(-1SFoSuXLktP8Fr2GYRmK|Y=Y=HO)fF8XKI&Rj208^vYZ>5bbqRh%%12#) zk(RAlkgIHh84 z<&2U=57I&=daPC?qR>m{`%&hSFfx&ZW_fF5_RCNxHq{F6r4;1l3cM0pL)3zu;vC6% zrS-HA>>cQo=SWtnyJwy99Lf0XSCA=of;_a6n0R}#Mfa^%yq(n1-W~BM^Na%N0Ey3U z@E?tgGOD$3r96IG?M`|8)nxf(By8`;Oj40rCgsC=)=R3f68&^5HbJeXO3Q>|hbNu+ zG^&)RF}@MHB%Mwsln_`Riv?j`$8T*x$evxjjHiTOTM&W^(_E5gWc@_&1p?s0Z#-;mGX!~c8wwhvLtah z)3KM*k{xP~k_50)C@p!It})7|vZFy34JOCzDj$};aP?513ASnwpxU}LCafa3slF%! zdJMZ7SxRYhrtiIKUOvK_;Eq-aG8hZVSW*Wm7Ro{1iJ_HZam>kBssLy#|K|BXO-Hpt zB{5+4m1}aar;)Y5aHx?pZ}=CLvpn`%6ikFGR;aa7xMSls!zwUkk2)ngHfG!Fnp0y0 zKro?i5MxuNvx!h;Vzh{irdH&leP)CJkhqE(-Rdo*1&_Y7J}$&?Xd}@ULXo2Yg_})K(2Z5Jj7%g$##W4hrWm2mI+SjS zMkbBenZ8i6OWuA&AzSd?iBPWePYZ!*0m;*9=Q&VBon;Vn)}T+x8da%rVDy9tLVcw! zL}A_m8d=K{=TY+pAsWK-xs@f6XH;$A@R->_Xv8oFJNVoEw_2&@%ipJ4EpR%yQINZ*CSj4a!NS~dShqNC!g zYW05>m&SyS&1&RAga6=ArO)l!T6zVSkrBUCa>egXDcXs96P0f`J2_D|sJe*`>r_RE zrLfWo_aaE>Y?tzkQY(FEwSA*niH%EP70~ImAD2#@oeWgj$-reP^mdOk@(o6G5Wr1` z8tn>~M42-RR#uinSQU*dgt&5s=4DYUC%{rIVgl?LmU))p~9{%L=?Mbh+|y2ni2+w z$UTyLy1r*Azl^>UA2ez+I&d$d#!4t@ccAZd8kgH@%xJRJ+{SRV0JkNREnJDT-Wh;S zr=N_iV=Hl`AXm0Ut^6l+*=1lZm4uA!cbMM}fwufV9%M7e@~o z%LhHUSM{aj$b!rH*fl{%C--WlYA01=q_mP0Ym1;IYAsYX-U&l9R&d1=n8JZ;qTZF< z0BhU|)8lP1CsR5K5H&t#C!I$$jP6{IywF=rKc$szVTqwGl3%$^Nntq*(-(4eBt?kk zT*n{$)zi!*zA#8a4B@Ta80oVJ^tJ7$BG7B$IxxaeUyO$O8fm3UM#kb{;CPC{Y*r~b z9BN(Jek_7|W6+>e+fgft$*Ik$bVn@oiq*Yi6Gg)naT7=*&RbQL{hyEVovI8akLMMeYbpwzUVzrt;jD6lBW zTZC8`!(o%h%UP~h;OcZ4MjtpfJzHFhw2zQ@%SS~Nya`bULRzpZe|o1fm^VCZlw-o}=r zaa98Sw0gS|=#Q^rs#pqF0yUG1Fv)75W4R{;9V)u0Z(6wuVDH*ga)H7A0K35IHmXWs zV+B+&O5e7+4l)_pL1%0ufvCVnyI|FlXJl>VWgV(DCk?8|>GFd( zR+z}s@mD;(yBE~t1E$8arsV0R>?x^FYo9WN^3aN zu~*iBHdg%sM~N^Rw|T%{!E>DoSQ7<5ek9IKh25juQ0P^|=F z8fo;+%sk|g3pM|}F6>X)r1V7^KEBsFXk={|O<0@BXrZcG5t>wd^ev8R}xP2xo^dU{T7k~V+bd4V_P}V2YREE1g23T0%5OmOwDOSlxpBQxAkwleW z0e~*IqC|2p1DAX8)6!d$=Z`OH+mw6JOx_>f|O>c_tF@>g)V<0l#S39KqD(6&mPyjbNxe9E$&7fxZG3jr6teE*qTOcIJ=kn;-byG z+>5bnkBQaDc5~%k%zs=L4#jl9p{P_UqE+hSF}1QhX|;RN3fl?Vy?Fh#)yuuC>DbA= z__LK_-hmmypn&7zLj`L3h@;BAD4z4BvvNW$Q@1O>L;(ioGD#f}d1vZljlS_zJ9RzZ zUQFvpEVQ?Jr!F`}NE!mY|JT zL~>xC@l`7}Ai|0fB!jLq1j@MQMpYgixas5t6rZ~fk<+SkPPO6$WLwx`=}YNV(TXq7YTin#YGh&=Sr@V`6;wpEEtOrmII_d3;;K0I zB^okS7POHwLQz?*wx{ar3eX|Pz_xdZZC%Hf^M1^^%3$(&6_Y#ErS6JYoydqVQGr#tuw2f7Y zfdJdP_yVn3g<>zoLt&(c31B2u4A@vurPdK7P!tmXDys|+0sl&ng2h7x7zjmu(QsL6 zJIPCCLYB1GOdY)~1VE(JD48+~wWwe}&r;t3DzJ97_yk zzFXRs7_8j2mKCo2Y+GVvV8dp7W|x(jizP0JmL+ca?rMn%hU_p=R-N9S8+RZq!zt^! z#q0=Mxqg0w$^N)7fd#4dr20bMs~A%6WEo3YSj2@DklEGVG(stA?qJ4h+zZ{$56m8m zZDSXmReO--W4Ag|gd|&>TAD(plewyuDT*(wNEC97TMqsF7F&)B-=ywvwo`0%(Y*$_ zq)G@ToCJVNAyqUQSa-GHO{qJyd%t%=z=p9IPRLKK!WoefKa0hs822^4PzfpI)cwM{ z2UYnXbr&5@7b+nbxDoxg*>O5(K$70oJSGat$#zU>kH;WeiN@Hh9 z7hQiDzFBltepAYKg)%GHDcf?-Y<-xP#;vks7xS_AV5ie0kPb zztBluAa;37-zX$a(Y_&2k#7}tEz$Rq8^z%+tvE?mv-@HuedD=DmJwBJ=FQQD`i8Dx z(ZLQ=JnluhP+Ak!jD=3=X}phAmpDp4Y+1;Te`!UXSh?;i9&9#iWO1l3Y0UEIMfu>v zkNCBb`_I05iD4WJUEEy<>ZUe|%aXln3fGk&^YBdU(L! z-TlM;mv?A{&Xkp7>+PGs9zh=kMPwUT5A!o}bKfiY>0jLa{oSvBbN_h%$=%`pukR1{ zzvut|^WBOiT7UK7zcofag76iUKZf8-wzV9*TfC7q?~Ey<^U~@kV+_aQt$Wj+-lP4- z!e3ASeVMt9{7a%L$og&ljlg-sW>)>cQ=VSdJs7!(;7gYNPPShT+K8GMj!e8AuYMg7 zSWojlSf2h)d}HCS$>B|(@5Rh*kUL%l;v)o#-14ct7uhPM{{JUfiM zm(<&cb|&G9BE7se>GTF}$)AUMb9Zae&a-oeaZUM#)SHNQMZy(DdP!{3+AUm@zZ&Z1 zqFv1nBOA)sq~1ofGYQue;ofGg-N3mo*Yel!##+0Y9Y)?u>TN_jlW& zqUg*C+N7o%xFvrc>h`vFo}DB0HRT&pZz9?i30D;9^6I3uTev2FHPp>TyP6$FHk7YP zy^UyR60RxY^5(3y8#wpn&cGVp*dVNChmrS^dK=NsBwSNOS#;Lg4V?QT+BLkjXy@5s zpQ;ff-i=uc|8g=_LxL)~1otJ!t1zovXm>TN_jlWN>!Rn;RR1)$B0xUQ%x(+L?rFiuirRS!*|N?u%&G@YbT8XNQsZk}A>G z)dnsKJnDYN4{;fzuSsz0f{PN{8y{ShIB=IvcW(Q-#u_I}+=VW7g>EHt4CiYk`hw1a zcchCKiX^Xb$iKon(uH;*pXKm-g?FTjTTjSqp=*VAq>Fo?$cxl7hov*zkE$a#3neYR z`0SI!72c69UWMbTZNe~0<}=)pDvp-8k39~jX1F6&yzwy0YKA*f#m#19HCAwj`%$Hz zHJfC$f;&>hi>{Nb^z%;x?no7HF>>v^SMW5$9jW4NBJQaUs%E$&Ra}UkWi`Y7sPc~) zEV5d`9jW5C(I#1)XSgF(dZTxe)eLu}ir*EQWi`VcsnR8U-UoC2i4w{T_oM2<1!Dc~ zMp3nbJ5t5H)=5^E8SY3Gw>@WB%`j9=x5s(AiT5;k*`B10{~VurH}D6&yWdOpr(E67 zvwc`1a%Uf?(RMlnt7GJ?U%x%oD@E!2R(p?er{TSJl zlYT_KE`c7n%jh=-xAM+q>mmNSd!46|f9}Fp?`wSP6*{qqjnG%U zuko!HVMPv$@V%J1;UYxJM}89AzvlQS-Egm`5&Ek4HNN#CtjJ*z)+)5UKc4I4-^tAF z7NH1JEz9pZZV8?5Vsqm*u$~4NAL)IKZ@dU=a;VUSymkWHEAjsVGdEm>P;%gQw%?iC z61uqoA6QS1MfpyA>qYoMnYrO2M65@Ca*N-!KzTM&pKov@^uT%=yy|_8Z@maBa=tG! zH(Z2>bvWif>Bj$X%=Pql;#)7m56a997a=$5N1m{`L%+He&W+Su10SJvJ^h{d){F3i zGIP5{SV@_St?SG7tLx*e!TK)y_ThEk8!y0$7#MjksW+5w=pa^hDPl_&F~jwn1bKLf z`#a#R<@>`iazp9Q@w=48)|n1I&8~Y+^g&8T!qd3^I=TpzGH2=_14m#i9wCN2P3zW z{z|?a1g-D)uWqbgU7z1RyzYBr>92@^k@ZdgRqHKn%ZiR`vgT{+S9j=FeXpc{Yx&Ls zg^>;AbL&mzJJWGZ)_ivz32xxr_e%P=mhVgqjJ%iB8`_7Nj%%{!3+za61LwY1(!aHQ zXJTOFy`k?>hgO@y`6klbX<|Oy2^fauYT3{ zO8Pg}-xV=1vVH|%)p|?&yQ1Totoc6s)#dtC-z(|gTE4SDVPr%3+kWZf`u#}DD-E41)f*0-@9ZnJ zywx!3pobOSTWCI|^%dTmxV+`CoI9`Z&cxNb56gLM-hCJ+uDfms zQNhij<(zVb_m-S$MCbeE{BDK!CNA$kEazG)yf<-q4Pw~2;|lLg-0E!zN>KB=5_^-D zS0dVV)f*E3CS2F*y$GbX$7>Sb5sT=Xwfar(E=|vH?*+{p5@SJUxHD<1*Ca@)^+m{j zF<@`f=659^ZH9Z3Hoq_dX*1lLwE3+GNSoo_q|L8RK-vsHdo^RvdW|nD^}ud`zI;q<{gvE6@LYarZ>=s}Y|(2&(_QxpUh<`2vEz zFQ`vA@Bs~fB1ue7cbf&(u=u`Nr=_=8IH_>+c*a#O*<9lisXtYJte` z>I)O!lVCnj!S#d_2`OLi&=%#ZC437g7+DtPE*mdusZO2ex456brL2Eo(k1JEiUL}u z|C;r$;>Y-zhd>wmSD~^!2Dyj2Aqma zx=yK&@aRi3!588e83TSmBA=(y*P{7c5ExF>YQz^^^zF(C^XVEPvQUYa%MEGO$Ms;J z?_p^k{X|BPTA@QvS8F~?L|;DCrdD24S6{*@zFE_V2vy&`oG?6S;bxwM$%jR?KMW=w z3-?0wcv}qRGI<(b-{gcg^W_g$3h`qfps!wU)$;!-FNr9&%p4+VuT%Y(1uNk@2LH+`8` zt%ZG&U38&C;)3r|k!^tVktYz-XC`l1zRwjp_*FQyg4D{oXy$5tB9#H*&$2GH%KZAY zq&Mq8e_!a<7KtLNEd(zQ>BTx7Ll{Gw743+A7yB!WXrHBs{rnbNhEqG+MxRtdpR)n| zeLP_c(;w3n(kG;(dikVO&26l)299-Go-d5M9M;SSDjCh6vDNpu^cif8uFYP^bZX%W zHy>2b^c6Cxkoj!fa_Q%{*m9isF1(K=JzB(!0&f*rvmU>5a zJ28O1%f&ByYq#?olimq@Ez8czKa8laa`7Uq#LI?2pj_tn4y{%`gr%8KgM6hcpAiJJ zLG=AEKg;*PR;`0B7DqF0aa+gkzs3HXuofd>rIx5=a%p6FO9pKGVI8!&X1v!252-!b;M*EQ6qwbwrem~0{KmME z4Vo%dF=6^(8fOMJ_?TJm&=X!*d(8L(vctp%+OU$(>nq|o0Ak5YBR;Ncu{Z8TJMode zv3psx#=YqM{1(H9m6zE~IpraYJjj&#JIE{rl$WZ@Y{M06znE=tE!z;Y4bq2Qg+eI| z#0EZzkCGp)`YiLnmgjDZ$_^1j9W$NyR-YI$zEExVLUhaowoWHzYSb~)f)!hUEXaFq;H_J9TPJ#nv=UkMet-T zFcQ`Io})Iewghx!qhtHk%FdBI5;MVrWl!Xi*1{b#@wD|VF%u&b9@<_} zF zq$D>;bl7>1RsvnkMCjuv2c9H5LI}3GI5Zmk7bf}8x3<$4*~KB&$XX=~bj=$S{xws# zq8eHi+iA7J19Hzgw7x`t_A-5>LGlAADM~0M9+=-<)FKdKq`k16yI62ePu9+&fU1T< z*d@#$%7-!W_<BS8QW#+tTyz8>pX5l5T`1{V0Yasxz)CGZ%RjNjzY$`~tl-IO~)k<+KC}9*847c)-`W7O1 z&d9+FU0C>Rfub`Q1)(%0KC1r~LsHs_gtg4rF)S67sh|cT92TW$l9oB@29o~>3YQA> zyOpFkBOzF|mV_;nfh_O6EEN)0O@T#>rCM+-6H-+bfcAlH17fLUNMxDXQt3=iIF?GC zWSEU$AIt_GtrP=hOC`NQbc`iS1s$AfEtaZrTdIDV?aodGVMwf+iMvZB;>JbCY^g-G zW=<>QRX`9+#XqZZ&O@%|1TjQaa|*{&sc$K@EtLeZSSqApw{2As|ETq%93Z>ewp1e6Nm;JNQVD5f zCzV?|_OetYY>olhu@_k?rEDS@U6wFVSuFxvGnEGxNh%CZtCGJUF@%$g=-ldjO0C#( zwGvcGbdDwm@(=1Pt;i^rhEPb$zr|RCSe71bi`(+hZpsruL76FS%LA4RE!zT@j@*WF z!S%32E;xv1ypYR`NX)j~K3eIsLul=4qvsMs3Yk&3M7(9_nU3&?Q{Bc(5HOsa;V zBYaljNC>Jd<^?k$u4cuPFbbk2ga92YHy#R8{jV^qXV=7d9Fd4N^MxOYy0LoV3!@}X zV%I>5PlCd=99OqeO^EenBwAGi(OArs`bwchk<}_b#WgW}Y(h$Vl5aMNY_X`2Yqzn} zyd@)J$zWj8q!nflOJcS+ux4unrWCFXDO<(Z)&isO)HYPD(2zc6q)qyCJF!)?Cin?U^Nf$~4(BoG~oiTH{V-dDRzJ%bto-sI_p%bb30LS9SzstIc{krqfJn zjdc?pqRL2PITjeLNhcO6F}SjfiRmsuShK`*jT6%$4M$d}fb9e$+va3%BMse!7&{*- zoz_$<93=EWz~RsNPW{Yp#+(iu6bNV>1Fs@xJwC_0b^t*nY# z$uAc>DVnRVt*BO57Ae`M*1zVpeOl46m(o62-eL&LibZPdYs~B{ey2hODit|IV501_!t)Kq=$dT zaTH=vxpk+7Nh_jEbGA&MhfNtTDaEI;ODWL4Wk zhvZq9|3C*wE?isDiptEDswpG_Ri>YiNLR`vkAy_b>%?vJt(B{h3pM|>F7Pk6T7BU^ z_0}3$YE0Ns^9G5BP}Qv!c8tEoQH@-v=FMrr>n}g~`rX^tAAfPjUtj&>@9+Nj_VuS+ zG<$XTIR5Yc3FC3O|MY(R8`j6I_g{{GJ0Q!ee?unQe>-APw*Ph_7});X6H31Qw<97L z|Mu?f$DhA>{r2vsKfU|lqtE~6Ye@d!S6_Yg?*6DNnRg%j)t8@s#XVB}{j;Clef{p^ Wx9`l`3#RFE_miLe$G`pM-Two1;^PGX literal 0 HcmV?d00001 diff --git a/editflow_code/gapwise_editflowsrun.jl b/editflow_code/gapwise_editflowsrun.jl new file mode 100644 index 0000000..f910cb4 --- /dev/null +++ b/editflow_code/gapwise_editflowsrun.jl @@ -0,0 +1,209 @@ +using Pkg +Pkg.activate(@__DIR__) +#Pkg.instantiate() +using Revise + +using Random +using Statistics +using Adapt +using Functors +using Flux +using Onion +using RandomFeatureMaps +using Zygote +Pkg.develop(path=joinpath(@__DIR__, "..")) +using Flowfusion +const FF = Flowfusion +include(joinpath(@__DIR__, "prob_model.jl")) +include(joinpath(@__DIR__, "helper_funcs.jl")) + +import CUDA + +# Device helpers +const _gpu_enabled = try + CUDA.has_cuda() +catch + false +end + +to_dev(x) = _gpu_enabled ? Adapt.adapt(CUDA.CuArray, x) : x +to_cpu(x) = _gpu_enabled ? Adapt.adapt(Array, x) : x +# move x to the same device type as y (Array or CuArray) +to_same_device(x, y) = (_gpu_enabled && (y isa CUDA.CuArray)) ? Adapt.adapt(CUDA.CuArray, x) : Adapt.adapt(Array, x) + +# Load PM target (brings PM and AA20) + +function make_minibatch(B::Int, P::FF.EditFlow; rng=Random.default_rng()) + K = P.k + x0s = Vector{FF.DiscreteState}(undef, B) + x1s = Vector{FF.DiscreteState}(undef, B) + for b in 1:B + # x1 from true PM + seq1 = sample(PM; rng=rng) + @assert all(1 .<= seq1 .<= K) + x1s[b] = FF.DiscreteState(K, seq1) + # x0: uniform tokens with random length in 1:10 (no BOS in x0) + L0 = rand(rng, 1:10) + seq0 = rand(rng, 1:K, L0) + x0s[b] = FF.DiscreteState(K, seq0) + end + ts = rand(rng, Float32, B) + return x0s, x1s, ts +end + + +############################ +# Gap-wise model + training +############################ + +# --- helper: build gap embeddings (pick one) --- +gaps_from_sites_dup(H) = hcat(@view(H[:,1:1,:]), @view(H[:,2:end,:]), @view(H[:,end:end,:])) + + +function gaps_from_sites_avg(H) + d, L, B = size(H) + if L == 1 + middle = @view H[:, 1:0, :] + else + @views middle = 0.5f0 .* (H[:, 1:L-1, :] .+ H[:, 2:L, :]) + end + # cat med dims=2 är säkrare på GPU än hcat i vissa kombinationer av views + return cat(@view(H[:, 1:1, :]), middle, @view(H[:, L:L, :]); dims=2) # d×(L+1)×B +end + +struct EditFlowModel{L} + layers::L +end +Flux.@layer EditFlowModel + +function EditFlowModel(; d=128, num_heads=8, nlayers=6, rff_dim=128, cond_dim=128, K::Int) + embedding = Flux.Embedding(K + 2 => d) + time_embed = Flux.Chain(RandomFourierFeatures(1 => rff_dim, 1.0f0), Dense(rff_dim => cond_dim)) + blocks = [Onion.AdaTransformerBlock(d, cond_dim, num_heads) for _ in 1:nlayers] + # --- split heads: ins on gaps, sub/del on sites --- + head_ins = Dense(d => K, bias=false) # applied on gaps (L+1) + head_sub = Dense(d => K, bias=false) # applied on sites (L) + head_del = Dense(d => 1, bias=false) # applied on sites (L) + rope = RoPE(d ÷ num_heads, 4096) + return EditFlowModel((; embedding, time_embed, blocks, head_ins, head_sub, head_del, rope, K)) +end + +# Forward: returns M of shape (2K+1, L+1, B) +function (model::EditFlowModel)(t, Xt_ms) + m = model.layers + X = FF.tensor(Xt_ms) + X = ndims(X) == 1 ? reshape(X, :, 1) : X + L, B = size(X) + + pmask = Zygote.@ignore FF.getlmask(Xt_ms) + Xp = X .+ 1 # embedding is 1-indexed + H = m.embedding(Xp) # d×L×B + + t = ndims(t) == 0 ? fill(Float32(t), B) : Float32.(t) + cond = m.time_embed(reshape(t, 1, B)) + + cond = to_same_device(cond, H) + pmask = Zygote.@ignore to_same_device(pmask, H) + rope = Zygote.@ignore to_same_device(m.rope[1:L], H) + + for blk in m.blocks + H = blk(H; cond, rope, kpad_mask=pmask) # d×L×B + end + + # --- gap embeddings & heads --- + Hg = gaps_from_sites_avg(H) # d×(L+1)×B (or use gaps_from_sites_dup) + ins = m.head_ins(Hg) # K×(L+1)×B + sub = m.head_sub(H) # K×L×B + del = m.head_del(H) # 1×L×B + + # pad sub/del with a zero last column to reach L+1 + @views sub_pad = cat(sub, sub[:, 1:1, :].*0; dims=2) + @views del_pad = cat(del, del[:, 1:1, :].*0; dims=2) + + # final combined logits (untransformed): (2K+1)×(L+1)×B + return vcat(ins, sub_pad, del_pad) +end + +# --- training loop (gap-wise) --- +function train_editflow!(P::FF.EditFlow, + model; + epochs::Int=1, + steps_per_epoch::Int=100, + batch_size::Int=64, + lr::Float32=1f-2, + seed::Int=42, + print_every::Int=25) + + rng = Random.MersenneTwister(seed) + Random.seed!(seed) + + # device + model = Functors.fmap(to_dev, model) + opt_state = Flux.setup(Flux.Adam(lr), model) + + for epoch in 1:epochs + for step in 1:steps_per_epoch + # 1) minibatch + x0s, x1s, ts = make_minibatch(batch_size, P; rng=rng) + Z0, Z1 = FF.align_and_batch(P, x0s, x1s) + Zt, Xt = FF.interpolate_Z_elementwise(P, Z0, Z1, ts) + + # prepend BOS to all streams + bos = P.bos_token + Zt = vcat(fill(bos, 1, batch_size), Zt) + Xt = vcat(fill(bos, 1, batch_size), Xt) + Z1 = vcat(fill(bos, 1, batch_size), Z1) + + # 2) gap-wise masks & multipliers + transition_mask = FF.transition_mask_from_Xt_gapwise(P, Xt) # (2K+1, L+1, B) + edit_multiplier = FF.remaining_edits_gapwise(P, Zt, Z1, Xt) # (2K+1, L+1, B) + @assert size(transition_mask) == size(edit_multiplier) + @assert size(transition_mask, 2) == size(Xt, 1) + 1 + + # scheduler + den = 1f0 .- P.κ.(ts); den = max.(den, 1f-2) + scheduler_scaling = P.dκ.(ts) ./ den # length B + + # 3) masked state → device + lmask = Xt .!= P.padding_token + cmask = trues(size(lmask)) + Xt_ms = FF.MaskedState(FF.DiscreteState(P.k, Xt), cmask, lmask) + + ts_d = to_dev(ts) + Xt_ms_d = to_dev(Xt_ms) + Tmask_d = to_dev(transition_mask) + Emult_d = to_dev(edit_multiplier) + sched_d = to_dev(reshape(Float32.(scheduler_scaling), 1, 1, :)) + + # 4) fwd + loss + update + loss, grad = Flux.withgradient(model) do m + M = m(ts_d, Xt_ms_d) # (2K+1, L+1, B) + # shape sanity + @assert size(M) == size(Tmask_d) == size(Emult_d) + FF.edit_loss_gapwise(P, M, Tmask_d, Emult_d, sched_d; eps=1f-8) + end + Flux.update!(opt_state, model, grad[1]) + + if step % print_every == 0 + @info "train-gapwise" epoch step loss=Float32(loss) + end + end + end + + return Functors.fmap(to_cpu, model) +end + +# PM is the target probability model and K is the alphabet size +K = PM.K +println("K: ", K) + +P = FF.EditFlow(K; bos_token=0) + +model = EditFlowModel(; d=128, num_heads=8, nlayers=4, rff_dim=128, cond_dim=128, K=K) + +# Train; returned model is on CPU +model = train_editflow!(P, model; epochs=10, steps_per_epoch=150, batch_size=256, lr=1f-3) + + + + diff --git a/editflow_code/gapwise_notebook.ipynb b/editflow_code/gapwise_notebook.ipynb new file mode 100644 index 0000000..e20058d --- /dev/null +++ b/editflow_code/gapwise_notebook.ipynb @@ -0,0 +1,1627 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m\u001b[1m Activating\u001b[22m\u001b[39m project at `~/dev/Flowfusion.jl/editflow_code`\n", + "\u001b[32m\u001b[1m Resolving\u001b[22m\u001b[39m package versions...\n", + "\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `~/dev/Flowfusion.jl/editflow_code/Project.toml`\n", + "\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `~/dev/Flowfusion.jl/editflow_code/Manifest.toml`\n", + "WARNING: using StatsBase.sample in module Main conflicts with an existing identifier.\n" + ] + }, + { + "data": { + "text/plain": [ + "plot_len_dist (generic function with 1 method)" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using Pkg\n", + "Pkg.activate(@__DIR__)\n", + "#Pkg.instantiate()\n", + "using Revise\n", + "\n", + "using Random\n", + "using Statistics\n", + "using Adapt\n", + "using Functors\n", + "using Flux\n", + "using Onion\n", + "using RandomFeatureMaps\n", + "using Zygote\n", + "\n", + "Pkg.develop(path=joinpath(@__DIR__, \"..\"))\n", + "using Flowfusion\n", + "const FF = Flowfusion\n", + "\n", + "include(joinpath(@__DIR__, \"prob_model.jl\"))\n", + "include(joinpath(@__DIR__, \"helper_funcs.jl\"))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "to_same_device (generic function with 1 method)" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import CUDA\n", + "\n", + "# Device helpers\n", + "const _gpu_enabled = try\n", + " CUDA.has_cuda()\n", + "catch\n", + " false\n", + "end\n", + "\n", + "to_dev(x) = _gpu_enabled ? Adapt.adapt(CUDA.CuArray, x) : x\n", + "to_cpu(x) = _gpu_enabled ? Adapt.adapt(Array, x) : x\n", + "# move x to the same device type as y (Array or CuArray)\n", + "to_same_device(x, y) = (_gpu_enabled && (y isa CUDA.CuArray)) ? Adapt.adapt(CUDA.CuArray, x) : Adapt.adapt(Array, x)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "make_minibatch (generic function with 1 method)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Load PM target (brings PM and AA20) and minibatch\n", + "\n", + "function make_minibatch(B::Int, P::FF.EditFlow; rng=Random.default_rng())\n", + " K = P.k\n", + " x0s = Vector{FF.DiscreteState}(undef, B)\n", + " x1s = Vector{FF.DiscreteState}(undef, B)\n", + " for b in 1:B\n", + " # x1 from true PM\n", + " seq1 = sample(PM; rng=rng)\n", + " @assert all(1 .<= seq1 .<= K)\n", + " x1s[b] = FF.DiscreteState(K, seq1)\n", + " # x0: uniform tokens with random length in 1:10 (no BOS in x0)\n", + " L0 = rand(rng, 1:10)\n", + " seq0 = rand(rng, 1:K, L0)\n", + " x0s[b] = FF.DiscreteState(K, seq0)\n", + " end\n", + " ts = rand(rng, Float32, B)\n", + " return x0s, x1s, ts\n", + "end\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "gaps_from_sites_avg (generic function with 1 method)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Gap-wise helpers\n", + "\n", + "gaps_from_sites_dup(H) = hcat(@view(H[:,1:1,:]), @view(H[:,2:end,:]), @view(H[:,end:end,:]))\n", + "\n", + "function gaps_from_sites_avg(H)\n", + " d, L, B = size(H)\n", + " if L == 1\n", + " middle = @view H[:, 1:0, :]\n", + " else\n", + " @views middle = 0.5f0 .* (H[:, 1:L-1, :] .+ H[:, 2:L, :])\n", + " end\n", + " # safer on GPU than hcat in some view combinations\n", + " return cat(@view(H[:, 1:1, :]), middle, @view(H[:, L:L, :]); dims=2) # d×(L+1)×B\n", + "end\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "EditFlowModel" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Model definition (gap-wise heads)\n", + "\n", + "struct EditFlowModel{L}\n", + " layers::L\n", + "end\n", + "Flux.@layer EditFlowModel\n", + "\n", + "function EditFlowModel(; d=128, num_heads=8, nlayers=6, rff_dim=128, cond_dim=128, K::Int)\n", + " embedding = Flux.Embedding(K + 2 => d)\n", + " time_embed = Flux.Chain(RandomFourierFeatures(1 => rff_dim, 1.0f0), Dense(rff_dim => cond_dim))\n", + " blocks = [Onion.AdaTransformerBlock(d, cond_dim, num_heads) for _ in 1:nlayers]\n", + " # split heads: ins on gaps, sub/del on sites\n", + " head_ins = Dense(d => K, bias=false) # gaps (L+1)\n", + " head_sub = Dense(d => K, bias=false) # sites (L)\n", + " head_del = Dense(d => 1, bias=false) # sites (L)\n", + " rope = RoPE(d ÷ num_heads, 4096)\n", + " return EditFlowModel((; embedding, time_embed, blocks, head_ins, head_sub, head_del, rope, K))\n", + "end\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Forward (returns logits of shape (2K+1, L+1, B))\n", + "function (model::EditFlowModel)(t, Xt_ms)\n", + " m = model.layers\n", + " X = FF.tensor(Xt_ms)\n", + " X = ndims(X) == 1 ? reshape(X, :, 1) : X\n", + " L, B = size(X)\n", + "\n", + " pmask = Zygote.@ignore FF.getlmask(Xt_ms)\n", + " Xp = X .+ 1 # embedding is 1-indexed\n", + " H = m.embedding(Xp) # d×L×B\n", + "\n", + " t = ndims(t) == 0 ? fill(Float32(t), B) : Float32.(t)\n", + " cond = m.time_embed(reshape(t, 1, B))\n", + "\n", + " cond = to_same_device(cond, H)\n", + " pmask = Zygote.@ignore to_same_device(pmask, H)\n", + " rope = Zygote.@ignore to_same_device(m.rope[1:L], H)\n", + "\n", + " for blk in m.blocks\n", + " H = blk(H; cond, rope, kpad_mask=pmask) # d×L×B\n", + " end\n", + "\n", + " # gap embeddings & heads\n", + " Hg = gaps_from_sites_avg(H) # d×(L+1)×B\n", + " ins = m.head_ins(Hg) # K×(L+1)×B\n", + " sub = m.head_sub(H) # K×L×B\n", + " del = m.head_del(H) # 1×L×B\n", + "\n", + " # pad sub/del with a zero FIRST column to align sites with gaps (site i ↔ gap i+1)\n", + " @views sub_pad = cat(sub[:, 1:1, :].*0, sub; dims=2)\n", + " @views del_pad = cat(del[:, 1:1, :].*0, del; dims=2)\n", + "\n", + " return vcat(ins, sub_pad, del_pad) # (2K+1)×(L+1)×B\n", + "end\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "train_editflow! (generic function with 1 method)" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Training loop (gap-wise)\n", + "function train_editflow!(P::FF.EditFlow,\n", + " model;\n", + " epochs::Int=1,\n", + " steps_per_epoch::Int=100,\n", + " batch_size::Int=64,\n", + " lr::Float32=1f-2,\n", + " seed::Int=42,\n", + " print_every::Int=25)\n", + "\n", + " rng = Random.MersenneTwister(seed)\n", + " Random.seed!(seed)\n", + "\n", + " # device\n", + " model = Functors.fmap(to_dev, model)\n", + " opt_state = Flux.setup(Flux.Adam(lr), model)\n", + "\n", + " for epoch in 1:epochs\n", + " for step in 1:steps_per_epoch\n", + " # 1) minibatch\n", + " x0s, x1s, ts = make_minibatch(batch_size, P; rng=rng)\n", + " Z0, Z1 = FF.align_and_batch(P, x0s, x1s)\n", + " Zt, Xt = FF.interpolate_Z_elementwise(P, Z0, Z1, ts)\n", + "\n", + " # prepend BOS to all streams\n", + " bos = P.bos_token\n", + " Zt = vcat(fill(bos, 1, batch_size), Zt)\n", + " Xt = vcat(fill(bos, 1, batch_size), Xt)\n", + " Z1 = vcat(fill(bos, 1, batch_size), Z1)\n", + "\n", + " # 2) gap-wise masks & multipliers\n", + " transition_mask = FF.transition_mask_from_Xt_gapwise(P, Xt) # (2K+1, L+1, B)\n", + " edit_multiplier = FF.remaining_edits_gapwise(P, Zt, Z1, Xt) # (2K+1, L+1, B)\n", + " @assert size(transition_mask) == size(edit_multiplier)\n", + " @assert size(transition_mask, 2) == size(Xt, 1) + 1\n", + "\n", + " # scheduler\n", + " den = 1f0 .- P.κ.(ts); den = max.(den, 1f-2)\n", + " scheduler_scaling = P.dκ.(ts) ./ den # length B\n", + "\n", + " # 3) masked state → device\n", + " lmask = Xt .!= P.padding_token\n", + " cmask = trues(size(lmask))\n", + " Xt_ms = FF.MaskedState(FF.DiscreteState(P.k, Xt), cmask, lmask)\n", + "\n", + " ts_d = to_dev(ts)\n", + " Xt_ms_d = to_dev(Xt_ms)\n", + " Tmask_d = to_dev(transition_mask)\n", + " Emult_d = to_dev(edit_multiplier)\n", + " sched_d = to_dev(reshape(Float32.(scheduler_scaling), 1, 1, :))\n", + "\n", + " # 4) fwd + loss + update\n", + " loss, grad = Flux.withgradient(model) do m\n", + " M = m(ts_d, Xt_ms_d) # (2K+1, L+1, B)\n", + " # shape sanity\n", + " @assert size(M) == size(Tmask_d) == size(Emult_d)\n", + " FF.edit_loss_gapwise(P, M, Tmask_d, Emult_d, sched_d; eps=1f-8)\n", + " end\n", + " Flux.update!(opt_state, model, grad[1])\n", + "\n", + " if step % print_every == 0\n", + " @info \"train-gapwise\" epoch step loss=Float32(loss)\n", + " end\n", + " end\n", + " end\n", + "\n", + " return Functors.fmap(to_cpu, model)\n", + "end\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "K: 20\n" + ] + }, + { + "data": { + "text/plain": [ + "EditFlowModel(\n", + " Embedding(22 => 128), \u001b[90m# 2_816 parameters\u001b[39m\n", + " Chain(\n", + " RandomFourierFeatures{Float32, Matrix{Float32}}(Float32[-2.4796202 13.478667 … 0.7362796 3.2408502]),\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " [\n", + " TransformerBlock(\n", + " Attention(\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " identity,\n", + " identity,\n", + " Onion.var\"#32#34\"(),\n", + " 16,\n", + " 16,\n", + " 8,\n", + " 8,\n", + " ),\n", + " StarGLU(\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(512 => 128; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " NNlib.swish,\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 … 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0], Float32[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 … 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 … 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0], Float32[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 … 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " identity,\n", + " ),\n", + " TransformerBlock(\n", + " Attention(\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " identity,\n", + " identity,\n", + " Onion.var\"#32#34\"(),\n", + " 16,\n", + " 16,\n", + " 8,\n", + " 8,\n", + " ),\n", + " StarGLU(\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(512 => 128; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " NNlib.swish,\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 … 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0], Float32[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 … 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 … 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0], Float32[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 … 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " identity,\n", + " ),\n", + " TransformerBlock(\n", + " Attention(\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " identity,\n", + " identity,\n", + " Onion.var\"#32#34\"(),\n", + " 16,\n", + " 16,\n", + " 8,\n", + " 8,\n", + " ),\n", + " StarGLU(\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(512 => 128; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " NNlib.swish,\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 … 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0], Float32[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 … 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 … 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0], Float32[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 … 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " identity,\n", + " ),\n", + " TransformerBlock(\n", + " Attention(\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " identity,\n", + " identity,\n", + " Onion.var\"#32#34\"(),\n", + " 16,\n", + " 16,\n", + " 8,\n", + " 8,\n", + " ),\n", + " StarGLU(\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(512 => 128; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " NNlib.swish,\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 … 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0], Float32[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 … 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 … 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0], Float32[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 … 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " identity,\n", + " ),\n", + " ],\n", + " Dense(128 => 20; bias=false), \u001b[90m# 2_560 parameters\u001b[39m\n", + " Dense(128 => 20; bias=false), \u001b[90m# 2_560 parameters\u001b[39m\n", + " Dense(128 => 1; bias=false), \u001b[90m# 128 parameters\u001b[39m\n", + " RoPE{Matrix{Float32}}(Float32[1.0 0.5403023 … -0.87528455 -0.065975994; 1.0 0.95041525 … 0.9552474 0.8159282; … ; 1.0 0.9999995 … -0.57972294 -0.5789079; 1.0 0.99999994 … 0.2726629 0.27235872], Float32[0.0 0.84147096 … -0.48360822 -0.9978212; 0.0 0.3109836 … 0.29580808 0.5781532; … ; 0.0 0.0009999999 … -0.8148137 -0.8153929; 0.0 0.0003162278 … 0.9621096 0.9621958]),\n", + " 20,\n", + ") \u001b[90m # Total: 82 trainable arrays, \u001b[39m1_339_392 parameters,\n", + "\u001b[90m # plus 3 non-trainable, 65_600 parameters, summarysize \u001b[39m5.364 MiB." + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Init and (optional) train\n", + "K = PM.K\n", + "println(\"K: \", K)\n", + "\n", + "P = FF.EditFlow(K; bos_token=0)\n", + "\n", + "model = EditFlowModel(; d=128, num_heads=8, nlayers=4, rff_dim=128, cond_dim=128, K=K)\n", + "nothing" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04359362f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.053738564f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04167632f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03297082f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.042898107f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.047004897f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.031407103f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.030527484f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.041389197f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.051030993f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.0374101f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04102195f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.026533976f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.0499959f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.025252756f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.0484398f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.045012593f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.0026780209f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.022234883f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.033060875f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.040637895f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.040437073f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.043794483f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.046099633f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03347337f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04562903f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.032486565f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.043220945f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.0533192f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.051970646f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04268508f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.035433292f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03389576f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.036275387f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.045071315f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.045323465f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.056931026f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.026995188f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03336398f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.039238736f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.029019509f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.029877104f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04230904f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.044586718f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.055617556f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.038598303f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.036317915f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.047106896f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.02729911f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.056716956f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.024726644f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.031491946f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.034738377f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.049314383f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.022996385f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.043030504f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.030262893f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04733412f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03622381f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04362139f0\n" + ] + }, + { + "data": { + "text/plain": [ + "EditFlowModel(\n", + " Embedding(22 => 128), \u001b[90m# 2_816 parameters\u001b[39m\n", + " Chain(\n", + " RandomFourierFeatures{Float32, Matrix{Float32}}(Float32[-2.4796202 13.478667 … 0.7362796 3.2408502]),\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " [\n", + " TransformerBlock(\n", + " Attention(\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " identity,\n", + " identity,\n", + " Onion.var\"#32#34\"(),\n", + " 16,\n", + " 16,\n", + " 8,\n", + " 8,\n", + " ),\n", + " StarGLU(\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(512 => 128; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " NNlib.swish,\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9009282, 0.97761583, 0.9507291, 0.9544557, 0.983698, 0.94406486, 0.91237503, 0.9546408, 0.9400282, 0.93728954 … 0.9278801, 0.9326202, 0.8544071, 0.9115099, 0.8849126, 0.8521641, 0.92149186, 0.98095, 0.93939257, 0.977308], Float32[0.0057168175, -0.009145045, -0.033722285, 0.001512183, 0.01333655, -0.033993997, -0.02151767, 0.025952183, 0.039521635, 0.018975694 … 0.0032535498, 0.038781144, -0.010275906, -0.007902587, 0.0082089575, 0.015708515, 0.0030700988, 0.0059594186, -0.03405106, 0.016013626], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9623362, 0.93352437, 0.93379855, 0.9493948, 1.028554, 0.9743394, 0.8508891, 0.98132527, 0.9344278, 0.9350113 … 0.9744629, 0.9529613, 0.9621484, 0.9163794, 0.94755214, 0.9175964, 0.96506524, 0.9665524, 0.91546625, 0.9949486], Float32[-0.012049371, 0.013126871, 0.0073394994, -0.012121293, -0.016715286, 0.009123021, 0.12233682, 0.014630274, -0.030255122, 0.008518288 … -0.011132118, 0.01053182, -0.0016366772, -0.032412138, -0.034123607, -0.0029400205, -0.0031507579, 0.021517577, 0.018651018, 0.021760372], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " identity,\n", + " ),\n", + " TransformerBlock(\n", + " Attention(\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " identity,\n", + " identity,\n", + " Onion.var\"#32#34\"(),\n", + " 16,\n", + " 16,\n", + " 8,\n", + " 8,\n", + " ),\n", + " StarGLU(\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(512 => 128; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " NNlib.swish,\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.88897645, 0.9766103, 0.9197018, 0.9204043, 0.9459889, 0.998207, 0.9029781, 0.9129902, 0.9343188, 0.90026766 … 0.90041107, 0.95305324, 0.93125725, 0.93120664, 0.96174604, 0.92172164, 0.95484656, 0.9365054, 0.94726926, 0.95914537], Float32[-0.024876244, -0.013372403, -0.023151278, 0.0058930805, 0.015150687, 0.00506514, 0.06569516, 0.039223198, -0.022336751, -0.0075592464 … 0.020853924, 0.020920396, 0.022881962, -0.014029156, -0.025372026, -0.030799348, -0.0028562285, 0.016975688, -0.02693857, 0.014985809], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.8949334, 0.96080613, 0.97868085, 0.9332595, 0.99603575, 0.9822569, 0.81842166, 1.0786498, 0.82465905, 1.0236325 … 1.0279346, 0.99247783, 0.9598536, 1.0668865, 1.0348728, 0.97679406, 1.1416314, 0.9691545, 0.9829652, 0.9567631], Float32[-0.028586997, 0.022033295, 0.0043230234, -0.017253224, 0.018280348, -0.0046796706, 0.1579363, 0.015386374, -0.13737288, -0.01732349 … -0.002627133, 0.012623082, 0.026784712, -0.03556591, -0.008950267, -0.0015624083, -0.043819655, -0.023381405, 0.017168993, -0.01367464], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " identity,\n", + " ),\n", + " TransformerBlock(\n", + " Attention(\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " identity,\n", + " identity,\n", + " Onion.var\"#32#34\"(),\n", + " 16,\n", + " 16,\n", + " 8,\n", + " 8,\n", + " ),\n", + " StarGLU(\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(512 => 128; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " NNlib.swish,\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.93196476, 0.96928746, 0.99993956, 0.966561, 0.97282875, 0.9290628, 0.86543846, 0.9901893, 0.9423256, 0.9461345 … 0.9819104, 0.9650237, 0.97143203, 1.0043927, 1.0046741, 0.9852849, 0.9995551, 0.94403285, 0.9784962, 0.9999178], Float32[0.005265708, -0.02571394, 0.0072728144, -0.002272927, -0.011670859, 0.01575806, 0.071842745, 0.0057321745, -0.01695154, 0.0033025448 … -0.035389263, -0.0024997725, -0.011022158, 0.0042375517, -0.028677516, -0.0134365475, -0.033173997, 0.00831741, -0.011757645, 0.014898374], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9558336, 0.97751004, 0.97629535, 1.0008391, 1.027303, 0.9920142, 0.93847626, 1.0232522, 0.97007394, 0.98495865 … 0.975234, 0.98128086, 1.0140299, 0.961463, 1.0209244, 0.9895201, 1.0035169, 0.9764949, 0.9712956, 0.9992766], Float32[-0.035114158, 0.009441036, 0.0013764837, -0.01886956, -0.013361261, 0.02365774, 0.07090634, 0.0082793, -0.067354, -0.03893483 … -0.0047005075, -0.009805776, 0.02273551, -0.021179873, -0.021423183, -0.032671858, -0.033467315, -0.034345157, -0.01578475, -0.010036208], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " identity,\n", + " ),\n", + " TransformerBlock(\n", + " Attention(\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " identity,\n", + " identity,\n", + " Onion.var\"#32#34\"(),\n", + " 16,\n", + " 16,\n", + " 8,\n", + " 8,\n", + " ),\n", + " StarGLU(\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(512 => 128; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " NNlib.swish,\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.93987024, 1.0141299, 0.94590473, 1.0398, 0.9685555, 0.9711986, 0.8357142, 0.9902968, 0.9614973, 0.986233 … 0.97533554, 0.99850684, 0.9468865, 0.9574326, 0.9989692, 0.9406473, 0.95291144, 0.9222057, 0.8843927, 0.97842926], Float32[-0.0002878682, -0.02697671, -0.011184995, 0.003966876, -0.009137481, -0.014782035, 0.075821735, -0.003926014, -0.04380838, 7.698221f-5 … -0.038504954, 0.010956845, 0.034050774, -0.016015368, -0.014015871, -0.019414632, -0.030451395, -0.0155181745, -0.030340765, 0.0006519265], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.99015504, 0.9972736, 0.9607575, 0.9881008, 1.0271544, 0.97107905, 0.9632005, 0.9456777, 0.94125587, 0.97891855 … 0.9640415, 0.96021736, 0.9862009, 1.017604, 0.94475704, 1.0080596, 1.0486706, 0.9568705, 1.0038033, 0.97236484], Float32[-0.03507125, 0.013651431, 0.009977945, -0.0022944945, -0.011060834, 0.042574823, 0.078900285, -0.012326445, -0.079122104, -0.0453799 … -0.020229638, -0.008847884, 0.0003417767, -0.07078015, -0.046866, -0.044151116, -0.053207915, -0.044059698, -0.008748555, 0.0016865802], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " identity,\n", + " ),\n", + " ],\n", + " Dense(128 => 20; bias=false), \u001b[90m# 2_560 parameters\u001b[39m\n", + " Dense(128 => 20; bias=false), \u001b[90m# 2_560 parameters\u001b[39m\n", + " Dense(128 => 1; bias=false), \u001b[90m# 128 parameters\u001b[39m\n", + " RoPE{Matrix{Float32}}(Float32[1.0 0.5403023 … -0.87528455 -0.065975994; 1.0 0.95041525 … 0.9552474 0.8159282; … ; 1.0 0.9999995 … -0.57972294 -0.5789079; 1.0 0.99999994 … 0.2726629 0.27235872], Float32[0.0 0.84147096 … -0.48360822 -0.9978212; 0.0 0.3109836 … 0.29580808 0.5781532; … ; 0.0 0.0009999999 … -0.8148137 -0.8153929; 0.0 0.0003162278 … 0.9621096 0.9621958]),\n", + " 20,\n", + ") \u001b[90m # Total: 82 trainable arrays, \u001b[39m1_339_392 parameters,\n", + "\u001b[90m # plus 3 non-trainable, 65_600 parameters, summarysize \u001b[39m5.364 MiB." + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Train; returned model is on CPU\n", + "model = train_editflow!(P, model; epochs=10, steps_per_epoch=150, batch_size=256, lr=1f-3)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "=== Gap-wise model samples (20) ===\n", + "[1] EVQVNESGKGL\n", + "[2] VVFLVQSGGGLVKKPGASVKVQ\n", + "[3] VQLVQGGVNLVKPGSAVKKP\n", + "[4] QVQVSGAMKRPG\n", + "[5] QVQLVKSGPGLVKPG\n", + "[6] QVQLRQSGYAEVKKPR\n", + "[7] EVELLRSGVLVKPGGD\n", + "[8] QVQLLVQSGAEVK\n", + "[9] EVHLRESGLGGLPS\n", + "[10] QVQRVQQDVKMPGA\n", + "[11] EVQLVHSGGG\n", + "[12] QLQLQESGGGLVQPGGSR\n", + "[13] QVQAQAGEAGVKP\n", + "[14] QVQLVQSGANVKRKGSS\n", + "[15] EVQLVESGGGLVPGSGLLRL\n", + "[16] VLQVQSRGVLVKPNGSVKK\n", + "[17] QVTLRRDSTSLVKKP\n", + "[18] QVQLVHSAEVK\n", + "[19] EVQLVLSGGGILRK\n", + "[20] EVQLVESGGGLV\n" + ] + } + ], + "source": [ + "function sample_gapwise_strings(P, model; N=20, ts=0.0f0:0.01f0:1.0f0, rng=Random.default_rng())\n", + " out = String[]\n", + " tg = collect(ts)\n", + " for _ in 1:N\n", + " x0s, _, _ = make_minibatch(1, P; rng=rng) # ta ett x0 per sample\n", + " x0 = x0s[1]\n", + " # lägg till BOS längst fram (träningen hade alltid BOS i pos 1)\n", + " x0_tokens = collect(FF.tensor(x0))\n", + " x0_bos = FF.DiscreteState(P.k, vcat(P.bos_token, x0_tokens))\n", + "\n", + " x = FF.rollout_gapwise(P, model, x0_bos, tg; rng=rng)\n", + " seq = collect(FF.tensor(x))\n", + " seq = filter(t -> t != P.bos_token && t != P.padding_token, seq)\n", + " push!(out, String(collect(AA20[seq])))\n", + " end\n", + " return out\n", + "end\n", + "\n", + "# Användning\n", + "rng = Random.MersenneTwister(42)\n", + "ts = 0.0f0:0.02f0:1.0f0\n", + "println(\"\\n=== Gap-wise model samples (20) ===\")\n", + "for (i, s) in enumerate(sample_gapwise_strings(P, model; N=20, ts=ts, rng=rng))\n", + " println(\"[\", i, \"] \", s)\n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Sampling and Levenshtein plot\n", + "using Random\n", + "n = 500\n", + "\n", + "#ts = 0.0f0:0.01f0:1.0f0\n", + "model_strings = sample_gapwise_strings(P, model; N=n, ts=ts, rng=rng)\n", + "\n", + "# Build training strings from PM parents (the data PM was built on)\n", + "train_states = [FF.DiscreteState(P.k, sample(PM; rng=Random.MersenneTwister(1000+i))) for i in 1:n]\n", + "train_strings = [state_to_PM_string(P, s) for s in train_states]\n", + "\n", + "# Independent validation strings sampled from PM\n", + "val_states = [FF.DiscreteState(P.k, sample(PM; rng=Random.MersenneTwister(1000+i+2*n))) for i in 1:n]\n", + "val_strings = [state_to_PM_string(P, s) for s in val_states]\n", + "val_strings = [s for s in val_strings if !(s in train_strings)]\n", + "\n", + "# Plot normalized Levenshtein vs. training set (distinct val/train)\n", + "plt = plot_lev_dist(\"model_vs_true\", val_strings, model_strings, train_strings; title=\"Model vs True (normalized Levenshtein)\")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pAA = plot_AA_dist(\"model_vs_true_AA\", val_strings, model_strings; title=\"AA frequency: Natural vs Generated\")\n", + "display(pAA)\n", + "\n", + "pLen = plot_len_dist(\"model_vs_true_len\", val_strings, model_strings; title=\"Length distribution: Natural vs Generated\")\n", + "display(pLen)\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Julia 1.11.6", + "language": "julia", + "name": "julia-1.11" + }, + "language_info": { + "file_extension": ".jl", + "mimetype": "application/julia", + "name": "julia", + "version": "1.11.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/editflow_code/helper_funcs.jl b/editflow_code/helper_funcs.jl index 2542202..e63df9a 100644 --- a/editflow_code/helper_funcs.jl +++ b/editflow_code/helper_funcs.jl @@ -1,3 +1,6 @@ +using StringDistances, Statistics, ProgressMeter, Plots, StatsBase + + # Sampling helpers function state_to_PM_string(P::FF.EditFlow, st::FF.DiscreteState) xs = FF.tensor(st) @@ -57,4 +60,105 @@ function to_aa_tokens(P::FF.EditFlow, st::FF.DiscreteState) end end return toks +end + +function min_lev_to_set(queries::Vector{String}, refs::Vector{String}; normalize::Bool=true) + d = Levenshtein() + ref_lens = length.(refs) + out = Vector{Float64}(undef, length(queries)) + @showprogress for (i, q) in enumerate(queries) + Lq = length(q) + best = typemax(Int); best_Lr = 1 + for (r, Lr) in zip(refs, ref_lens) + lb = abs(Lq - Lr) + lb >= best && continue + dist = evaluate(d, q, r) + if dist < best + best = dist; best_Lr = Lr + best == 0 && break + end + end + out[i] = normalize ? best / max(Lq, best_Lr) : best + end + return out +end + +function plot_lev_dist(name, val_seqs, gen_seqs, train_seqs; title="Novelty vs. training set", max_seqs=1000) + sample_if_large(seqs, n=max_seqs) = length(seqs) > n ? rand(seqs, n) : seqs + + val_sample = sample_if_large(val_seqs) + gen_sample = sample_if_large(gen_seqs) + train_sample = sample_if_large(train_seqs) + + val_lev = min_lev_to_set(val_sample, train_sample; normalize=true) + gen_lev = min_lev_to_set(gen_sample, train_sample; normalize=true) + + # Robust bins even when all values are identical + minv = minimum([minimum(val_lev), minimum(gen_lev)]) + maxv = maximum([maximum(val_lev), maximum(gen_lev)]) + bins = (minv == maxv) ? range(0.0, 1.0, length=25) : range(minv, maxv, length=25) + p = histogram(val_lev; normalize=:probability, alpha=0.5, label="Natural", + bins=bins, xlabel="Min normalized Levenshtein", ylabel="Density", title=title) + histogram!(gen_lev; normalize=:probability, alpha=0.5, label="Generated", bins=bins) + + #println("val_lev: ", val_lev) + #println("gen_lev: ", gen_lev) + + #path = joinpath(@__DIR__, "figures", "$(name).pdf") + #mkpath(dirname(path)) + #savefig(p, path) + #savefig(p, "/figures/$(name).pdf") + return p +end + +function AA_counts(seqs) + counts = countmap(Iterators.flatten(seqs)) + labels = sort!(collect(keys(counts))) + return labels, counts +end + +function plot_AA_dist(name, real_seqs, gen_seqs; title="Normalized AA frequencies") + # Always show the full alphabet and filter invalid chars + labels = collect(AA20) + alphabet = Set(labels) + r_counts = countmap(Iterators.flatten((ch for s in real_seqs for ch in s if ch in alphabet))) + g_counts = countmap(Iterators.flatten((ch for s in gen_seqs for ch in s if ch in alphabet))) + r = Float64[get(r_counts, c, 0) for c in labels] + g = Float64[get(g_counts, c, 0) for c in labels] + rs = sum(r); r = rs > 0 ? r ./ rs : fill(0.0, length(r)) + gs = sum(g); g = gs > 0 ? g ./ gs : fill(0.0, length(g)) + # Grouped bars without unsupported bar_position + p = bar(string.(labels), [r g]; + label=["Natural" "Generated"], xlabel="AA", ylabel="Proportion", + title=title, alpha=0.5) + return p +end + +function len_dist(seqs; fig_name="len_dist.pdf", sort_labels=true) + isempty(seqs) && return (Int[], Float64[]) + # Count only AA20 letters (ignore BOS '>' and any non-AA chars) + alphabet = Set(AA20) + lens = [count(ch -> ch in alphabet, s) for s in seqs] + cm = countmap(lens) # how many seqs of each length + Ls = collect(keys(cm)) + sort_labels && sort!(Ls) + props = [cm[L] for L in Ls] ./ max(length(lens), 1) + return Ls, props +end +function plot_len_dist(name, real_seqs, gen_seqs; title="Sequence length distribution") + real_labels, real_props = len_dist(real_seqs) + gen_labels, gen_props = len_dist(gen_seqs) + + # Build unified x-axis and zero-fill missing bins + all_labels = sort!(union(real_labels, gen_labels)) + rmap = Dict(real_labels .=> real_props) + gmap = Dict(gen_labels .=> gen_props) + r = [get(rmap, L, 0.0) for L in all_labels] + g = [get(gmap, L, 0.0) for L in all_labels] + + p = bar(string.(all_labels), [r g]; + label=["Natural" "Generated"], xlabel="Length", ylabel="Proportion", + title=title, alpha=0.5) + #savefig(p, "../img/unconditional/len_dist_$(name).pdf") + return p end \ No newline at end of file diff --git a/editflow_code/jack.jl b/editflow_code/jack.jl new file mode 100644 index 0000000..bd7ea17 --- /dev/null +++ b/editflow_code/jack.jl @@ -0,0 +1,200 @@ +using Pkg +Pkg.activate(".") +ENV["CUDA_VISIBLE_DEVICES"] = 1 +using Revise, Random, Statistics, Adapt, Functors, Flux, Onion, RandomFeatureMaps, Zygote, CannotWaitForTheseOptimisers, CodecZlib, CSV, LearningSchedules, DataFrames, Distributions +using Flowfusion +const FF = Flowfusion +include("scripts/model_training/editflows/prob_model.jl") +include("scripts/model_training/editflows/helper_funcs.jl") +include("scripts/misc/data_loading.jl") +import CUDA + +# Device helpers +const _gpu_enabled = try + CUDA.has_cuda() +catch + false +end + +to_dev(x) = _gpu_enabled ? Adapt.adapt(CUDA.CuArray, x) : x +to_cpu(x) = _gpu_enabled ? Adapt.adapt(Array, x) : x +to_same_device(x, y) = (_gpu_enabled && (y isa CUDA.CuArray)) ? Adapt.adapt(CUDA.CuArray, x) : Adapt.adapt(Array, x) + +# Load PM target (brings PM and AA20) + +struct EditFlowModel{L} + layers::L +end +Flux.@layer EditFlowModel + +function EditFlowModel(; d=128, num_heads=8, nlayers=6, rff_dim=128, cond_dim=128, K::Int) + embedding = Flux.Embedding(K + 2 => d) + time_embed = Flux.Chain(RandomFourierFeatures(1 => rff_dim, 1.0f0), Dense(rff_dim => cond_dim)) + blocks = [Onion.AdaTransformerBlock(d, cond_dim, num_heads) for _ in 1:nlayers] + head_combined = Dense(d => 2K + 1, bias=false) + rope = RoPE(d ÷ num_heads, 512) + return EditFlowModel((; embedding, time_embed, blocks, head_combined, rope, K)) +end + +function (model::EditFlowModel)(t, Xt_ms) + m = model.layers + X = FF.tensor(Xt_ms) + X = ndims(X) == 1 ? reshape(X, :, 1) : X + L, B = size(X) + + pmask = Zygote.@ignore FF.getlmask(Xt_ms) + Xp = X .+ 1 + H = m.embedding(Xp) + + t = ndims(t) == 0 ? fill(Float32(t), B) : Float32.(t) + cond = m.time_embed(reshape(t, 1, B)) + + cond = to_same_device(cond, H) + pmask = Zygote.@ignore to_same_device(pmask, H) + rope = Zygote.@ignore to_same_device(m.rope[1:L], H) + + for blk in m.blocks + H = blk(H; cond, rope, kpad_mask=pmask) + end + return m.head_combined(H) +end + +data = readlines("data/oas_heavy_8M.txt") + +K = PM.K +P = FF.EditFlow(K; bos_token=0) +epochs = 1; batch_size = 64 + +model = EditFlowModel(; d=512, num_heads=8, nlayers=12, rff_dim=512, cond_dim=512, K=K) +const START_LR = 1f-3 +const MAX_LR = 1f-3 +const UP_GAMMA = 1.00f0 +const DOWN_GAMMA = 0.99994398f0 + +sched = burnin_learning_schedule(START_LR, MAX_LR, UP_GAMMA, DOWN_GAMMA) +for layer in model.layers.blocks + layer.attention_norm.scale.weight .= 0.0f0 + layer.attention_norm.shift.weight .= 0.0f0 + layer.ffn_norm.scale.weight .= 0.0f0 + layer.ffn_norm.shift.weight .= 0.0f0 +end + +rng = Random.MersenneTwister(seed) +Random.seed!(seed) +global_step = 1 +model = Functors.fmap(to_dev, model) +sched = burnin_learning_schedule(START_LR, MAX_LR, UP_GAMMA, DOWN_GAMMA) + +# do learning rate warmdown +total_iters = div(512000, batch_size) +DECAY_STEPS = 8000 +get_lr(i) = 1f-3 + (1f-7 - 1f-3) * (Float32(min(i, DECAY_STEPS)) / Float32(DECAY_STEPS)) +opt_state = Flux.setup(Muon(eta=get_lr(1)), model) + +for epoch in 1:epochs + # for (step, seqs) in enumerate(stream_heavy_batches(path; L=140, batch=batch_size, total=10^6)) + for step in 1:total_iters + seqs = [rand(data) for _ in 1:batch_size] + xpairs = format_for_editflows(seqs) + x0s = [p[1] for p in xpairs] + x1s = [p[2] for p in xpairs] + ts = rand(Float32, batch_size) + # align_and_batch basically + Z0, Z1 = try + FF.align_and_batch(P, x0s, x1s) + catch e + if e isa LoadError || e isa ArgumentError + @warn "skip batch due to Data loading error" err=e + continue + else + rethrow(e) + end + end + Zt, Xt = FF.interpolate_Z_elementwise(P, Z0, Z1, ts) + #Append BOS token to the beginning of the batch + bos = P.bos_token + Zt = vcat(fill(bos, 1, batch_size), Zt) + Xt = vcat(fill(bos, 1, batch_size), Xt) + Z1 = vcat(fill(bos, 1, batch_size), Z1) + + transition_mask = FF.transition_mask_from_Xt(P, Xt) + edit_multiplier = FF.remaining_edits(P, Zt, Z1, Xt) + den = (1f0 .- P.κ.(ts)) .+ 0.2f0 + scheduler_scaling = P.dκ.(ts) ./ den + # 3) Masked state (CPU → device) + lmask = Xt .!= P.padding_token + cmask = trues(size(lmask)) + Xt_ms = FF.MaskedState(FF.DiscreteState(P.k, Xt), cmask, lmask) + ts_d = to_dev(ts) + Xt_ms_d = to_dev(Xt_ms) + Tmask_d = to_dev(transition_mask) + Emult_d = to_dev(edit_multiplier) + sched_d = to_dev(reshape(Float32.(scheduler_scaling), 1, 1, :)) + loss, grad = try + Flux.withgradient(model) do m + M = m(ts_d, Xt_ms_d) + FF.edit_loss(P, M, Tmask_d, Emult_d, sched_d; eps=1f-8) + end + catch e + if e isa DimensionMismatch + @warn "skip batch due to DimensionMismatch" err=e + continue + else + rethrow(e) + end + end + if Float32(loss) < 0 + @warn "negative loss at step $step" + continue + end + open("losses/EDITFLOWS.csv", "a") do io + println(io, "$(global_step),$(epoch),$(step),$(Float32(loss)),$(get_lr(step)),$(time())") + end + Flux.adjust!(opt_state, get_lr(step)) + Flux.update!(opt_state, model, grad[1]) + if step % 10 == 0 + @info "EditFlows" epoch step loss=Float32(loss) + end + if step % 500 == 0 + samples = sample_gen_10_strings(P, Functors.fmap(to_cpu, model), n=5) + CSV.write("gens/samples_step_$(step).csv",DataFrame(step = fill(step, length(samples)), sample = samples)) + end + global_step += 1 + end +end + +model_name = "EDITFLOWS" +using JLD2 +model_state = Flux.state(cpu(model)) +model_state_file = "models/model_state_"*model_name*".jld2" +JLD2.@save model_state_file model_state + +open("losses/loss_$(model_name).txt", "w") do io + println.(io, losses) +end + +rng = Random.MersenneTwister(42) +println("\n=== True PM samples (20) ===") +for i in 1:20 + seq = sample(PM; rng=rng) # Vector{Int} in 1..K_AA + aa_str = String(collect(AA20[seq])) + println("[", i, "] ", aa_str) +end + +gens = sample_gen_10_strings(P, Functors.fmap(to_cpu, model); ts=0f0:0.005f0:1f0, n=500) +gens = replace.(gens, ">"=>"") +open("gens/$(model_name)_gens.txt", "w") do io + println.(io, gens) +end + +println("\n=== Model samples (10) ===") +for (i, s) in enumerate(gens) + if s isa AbstractString + println("[", i, "] ", s) + elseif s isa AbstractVector{<:AbstractString} + last_str = isempty(s) ? "" : s[end] + println("[", i, "] traj_last=", last_str, " (len=", length(s), ")") + else + println("[", i, "] (raw) ", s) + end +end diff --git a/editflow_code/jackcomparison.jl b/editflow_code/jackcomparison.jl new file mode 100644 index 0000000..e69de29 diff --git a/editflow_code/test/runtests.jl b/editflow_code/test/runtests.jl index 011c0e8..98dc973 100644 --- a/editflow_code/test/runtests.jl +++ b/editflow_code/test/runtests.jl @@ -17,18 +17,19 @@ using Test # ───────────────────────────────────────────────────────────────────── # remaining_edits: simple 1-column case Zt = [0; 7; 23; 23; 4; 23; 22;;] + Xt = [0; 7; 4; 22;;] Z1 = [0; 7; 20; 20; 4; 10; 22;;] - expected = zeros(Float32, 2*tokens+1, 4, 1) + expected = zeros(Float32, 2*tokens+1, size(Xt)...) expected[20,2,1] = 2 expected[10,3,1] = 1 - got = FF.remaining_edits(P, Zt, Z1) + got = FF.remaining_edits(P, Zt, Z1, Xt) @test got == expected - # Two-column case with inserts/subs Zt = [0 0; 7 23; 15 15; 15 15; 23 4; 2 2; 22 22;] + Xt = [0 0; 7 15; 15 15; 15 4; 2 2] Z1 = [0 0; 7 7; 20 20; 20 20; 5 4; 10 10; 22 22;] - expected = zeros(Float32, 2*tokens+1, 6, 2) + expected = zeros(Float32, 2*tokens+1, size(Xt)...) expected[5, 4, 1] = 1 expected[tokens+10,5,1] = 1 expected[tokens+10,5,2] = 1 @@ -37,25 +38,27 @@ using Test expected[tokens+20, 3, 1] = 1 expected[tokens+20, 2, 2] = 1 expected[7, 1, 2] = 1 - got = FF.remaining_edits(P, Zt, Z1) + got = FF.remaining_edits(P, Zt, Z1, Xt) @test got == expected # deletions case Zt = [0 0; 7 7; 20 20; 20 20; 4 4; 19 19; 22 22;] + Xt = [0 0; 7 7; 20 20; 20 20; 4 4; 19 19; 22 22;] Z1 = [0 0; 7 7; 23 23; 20 23; 4 4; 23 23; 22 22;] - expected = zeros(Float32, 2*tokens+1, 7, 2) + expected = zeros(Float32, 2*tokens+1, size(Xt)...) expected[2*tokens+1,3,1] = 1 expected[2*tokens+1,6,1] = 1 expected[2*tokens+1,3,2] = 1 expected[2*tokens+1,4,2] = 1 expected[2*tokens+1,6,2] = 1 - got = FF.remaining_edits(P, Zt, Z1) + got = FF.remaining_edits(P, Zt, Z1, Xt) @test got == expected # mixed inserts/subs case Zt = [0 0; 7 7; 15 15; 15 15; 23 4; 2 2; 22 22;] + Xt = [0 0; 7 7; 15 15; 15 15; 2 4; 22 2;] Z1 = [0 0; 7 7; 20 20; 20 20; 5 4; 10 10; 22 22;] - expected = zeros(Float32, 2*tokens+1, 7, 2) + expected = zeros(Float32, 2*tokens+1, size(Xt)...) expected[5, 4, 1] = 1 expected[tokens+20,3,1] = 1 expected[tokens+20,4,1] = 1 @@ -63,7 +66,7 @@ using Test expected[tokens+20,3,2] = 1 expected[tokens+20,4,2] = 1 expected[tokens+10,6,2] = 1 - got = FF.remaining_edits(P, Zt, Z1) + got = FF.remaining_edits(P, Zt, Z1, Xt) @test got == expected # ───────────────────────────────────────────────────────────────────── @@ -110,3 +113,159 @@ using Test end +@testset "EditFlow gap-wise inserts: remaining_edits, transition mask, loss" begin + tokens = 21 + pad = 22 + lat = 23 + bos = 0 + P = Flowfusion.EditFlow(tokens; transform=identity, padding_token=pad, latent_token=lat, bos_token=bos) + + # ───────────────────────────────────────────────────────────────────── + # remaining_edits: simple 1-column case (gap-wise) + # Xt has L=4 rows → gaps = 1..4 + Zt = [0; 7; 23; 23; 4; 23; 22;;] + Xt = [0; 7; 4; 22;;] + Z1 = [0; 7; 20; 20; 4; 10; 22;;] + expected = zeros(Float32, 2*tokens+1, size(Xt,1)+1, size(Xt,2)) # (2K+1, L+1=5? careful: size(Xt,1)=4 -> L+1=5 ; but real Lb=3 → valid gaps 1..4) + # Inserts are on gaps: + # - two '20' inserted between 7 and 4 -> gap 3 + # - one '10' inserted after 4 -> gap 4 + expected[20, 3, 1] = 2 + expected[10, 4, 1] = 1 + got = FF.remaining_edits_gapwise(P, Zt, Z1, Xt) + @test got == expected + + # Two-column case with inserts/subs (gap-wise inserts) + Zt = [0 0; 7 23; 15 15; 15 15; 23 4; 2 2; 22 22;] + Xt = [0 0; 7 15; 15 15; 15 4; 2 2] # L=5 → gaps 1..6 + Z1 = [0 0; 7 7; 20 20; 20 20; 5 4; 10 10; 22 22;] + expected = zeros(Float32, 2*tokens+1, size(Xt,1)+1, size(Xt,2)) # (2K+1, 6, 2) + + # sample 1 (b=1): + # subs: 15→20 at sites 3 & 4, 2→10 at site 5 + expected[tokens+20, 3, 1] = 1 + expected[tokens+20, 4, 1] = 1 + expected[tokens+10, 5, 1] = 1 + # insert: LAT→5 occurs after site 4 (between 15 and 2) → gap 5 + expected[5, 5, 1] = 1 + + # sample 2 (b=2): + # insert: LAT→7 occurs after site 1 (between BOS and first real) → gap 2 + expected[7, 2, 2] = 1 + # subs: 15→20 at sites 2 & 3, 2→10 at site 5 + expected[tokens+20, 2, 2] = 1 + expected[tokens+20, 3, 2] = 1 + expected[tokens+10, 5, 2] = 1 + + got = FF.remaining_edits_gapwise(P, Zt, Z1, Xt) + @test got == expected + + # deletions case (gap-wise array but deletions live on sites) + Zt = [0 0; 7 7; 20 20; 20 20; 4 4; 19 19; 22 22;] + Xt = [0 0; 7 7; 20 20; 20 20; 4 4; 19 19; 22 22;] # L=7 → gaps 1..8 + Z1 = [0 0; 7 7; 23 23; 20 23; 4 4; 23 23; 22 22;] + expected = zeros(Float32, 2*tokens+1, size(Xt,1)+1, size(Xt,2)) + + # sample 1 deletions at sites 3 and 6 + expected[2*tokens+1, 3, 1] = 1 + expected[2*tokens+1, 6, 1] = 1 + # sample 2 deletions at sites 3,4,6 + expected[2*tokens+1, 3, 2] = 1 + expected[2*tokens+1, 4, 2] = 1 + expected[2*tokens+1, 6, 2] = 1 + + got = FF.remaining_edits_gapwise(P, Zt, Z1, Xt) + @test got == expected + + # mixed inserts/subs case (gap-wise) + Zt = [0 0; 7 7; 15 15; 15 15; 23 4; 2 2; 22 22;] + Xt = [0 0; 7 7; 15 15; 15 15; 2 4; 22 2;] # L=6 → gaps 1..7 + Z1 = [0 0; 7 7; 20 20; 20 20; 5 4; 10 10; 22 22;] + expected = zeros(Float32, 2*tokens+1, size(Xt,1)+1, size(Xt,2)) + + # sample 1: subs at sites 3,4 and 5; insert '5' at gap 5 + expected[tokens+20, 3, 1] = 1 + expected[tokens+20, 4, 1] = 1 + expected[tokens+10, 5, 1] = 1 + expected[5, 5, 1] = 1 + + # sample 2: subs at sites 3,4 and 6 + expected[tokens+20, 3, 2] = 1 + expected[tokens+20, 4, 2] = 1 + expected[tokens+10, 6, 2] = 1 + + got = FF.remaining_edits_gapwise(P, Zt, Z1, Xt) + @test got == expected + + # ───────────────────────────────────────────────────────────────────── + # transition mask from Xt (gap-wise) + Xt = [0 0; 7 7; 20 20; 20 20; 5 4; 10 22; 22 22;] # L=7 → gaps 1..8 + expected = ones(Float32, 2*tokens+1, size(Xt,1)+1, size(Xt,2)) + + # Helper to apply rules programmatically (mirrors gap-wise mask fn) + function fill_expected_mask!(E, x::Vector{Int}, b::Int) + L = length(x) + Lb = count(!=(pad), x) + + # sub/del never valid at last column (gap L+1) + E[(tokens+1):(2*tokens+1), L+1, b] .= 0 + + # pre-BOS insert forbidden + E[1:tokens, 1, b] .= 0 + + # padding sites off + if Lb < L + E[:, (Lb+1):L, b] .= 0 + end + # inserts beyond gap (Lb+1) off + if (Lb+1) < (L+1) + E[1:tokens, (Lb+2):(L+1), b] .= 0 + end + + for i in 1:Lb + t = x[i] + if t == bos + # block all subs at BOS and delete BOS + E[(tokens+1):(2*tokens), i, b] .= 0 + E[2*tokens+1, i, b] = 0 + else + # self-sub off + E[tokens + t, i, b] = 0 + end + end + return E + end + + expected = fill_expected_mask!(expected, Xt[:,1], 1) + expected = fill_expected_mask!(expected, Xt[:,2], 2) + + got = FF.transition_mask_from_Xt_gapwise(P, Xt) + @test got == expected + + # ───────────────────────────────────────────────────────────────────── + # loss equivalence under identity transform — with L+1 axis + # Make tiny tensors of shape (C=2, L+1=3, B=2); third column is masked out. + edit_multiplier = reshape(Float32[ + 0, 2, 0, 1, 0, 0, # batch 1 (cols 1..3) + 1, 0, 0, 0, 1, 0 # batch 2 + ], (2, 3, 2)) + + transition_mask = reshape(Float32[ + 1, 0, 0, 1, 0, 0, + 1, 0, 0, 0, 1, 0 + ], (2, 3, 2)) + + M = reshape(Float32[ + 0.1, 0.2, 0.0, 0.3, 0.4, 0.0, + 0.5, 0.6, 0.0, 0.7, 0.8, 0.0 + ], (2, 3, 2)) + + t = reshape(Float32[0.3, 0.7], (1, 2)) # per-batch scheduler t + k(t)=t; dk(t)=1 + scheduler_scaling = dk.(t) ./ (1 .- k.(t)) + + # Manual loss matches your earlier numbers (3rd col masked out) + l = (0.1+0.3+0.5+0.8 - (1/(1-0.3)*(2*log(0.2)+log(0.3)) + 1/(1-0.7)*(log(0.5)+log(0.8))))/2 + got = Flowfusion.edit_loss(P, M, transition_mask, edit_multiplier, scheduler_scaling; op_mask=nothing, eps=1e-9) + @test isapprox(got, l; atol=1e-7, rtol=1e-7) +end diff --git a/src/editflows.jl b/src/editflows.jl index 351b705..3087689 100644 --- a/src/editflows.jl +++ b/src/editflows.jl @@ -16,6 +16,24 @@ EditFlow(k; transform = NNlib.softplus, bos_token::Int = 0) = EditFlow(k, transform, κ, dκ, padding_token, latent_token, bos_token) +""" + EditFlow_cubic(k; transform=NNlib.softplus, padding_token=k+1, latent_token=k+2, bos_token=0) + +Convenience constructor that uses a cubic scheduler: +- κ(t) = t^3 +- dκ(t) = 3t^2 + +Compatible with both scalar and broadcasted usage (the codebase typically calls `P.κ.(ts)` and also `P.κ(ts[j])`). +""" +EditFlow_cubic(k; transform = NNlib.softplus, + padding_token::Int = k + 1, + latent_token::Int = k + 2, + bos_token::Int = 0) = begin + κ_cubic(t) = t^3 + dκ_cubic(t) = 3 * (t^2) + EditFlow(k, transform, κ_cubic, dκ_cubic, padding_token, latent_token, bos_token) +end + # Random padding of latent tokens to align the lengths of the sequences pairs (z0, z1) # And afterwards batch the sequences with padding tokens into a single matrix (Z0, Z1) @@ -124,6 +142,55 @@ function transition_mask_from_Xt(P::EditFlow, Xt::AbstractMatrix{<:Integer}) return T end +# Drop-in replacement (renames ok): now returns (2K+1, L+1, B) +function transition_mask_from_Xt_gapwise(P::EditFlow, Xt::Matrix{Int}) + K = P.k + PAD = P.padding_token + BOS = P.bos_token + + L, B = size(Xt) + M = ones(Float32, 2K+1, L+1, B) + + for b in 1:B + x = Xt[:,b] + # real length (incl. BOS), sites 1..L_b; gaps 1..L_b+1 + Lb = count(t -> t != PAD, x) + + # 1) mask padding columns for sites/gaps beyond sequence + # - inserts valid only on gaps 1..Lb+1 + if Lb < L + M[1:K, (Lb+2):(L+1), b] .= 0f0 # extra gaps off + M[(K+1):(2K+1), (Lb+1):(L+1), b] .= 0f0 # sub/del beyond Lb off + else + # only the last pad gap (L+1) exists; keep it on for inserts, off for sub/del below + nothing + end + # sub/del never valid at the last gap column + M[(K+1):(2K+1), L+1, b] .= 0f0 + + # 2) per-site constraints + for i in 1:Lb + t = x[i] + # no self-sub, and typically no subs at BOS (policy) + if t == BOS + M[(K+1):(2K), i, b] .= 0f0 # block all subs at BOS + M[(2K+1), i, b] = 0f0 # block delete BOS + else + M[K + t, i, b] = 0f0 # block self-sub to current t + end + end + + # 3) no ops on padding sites + if Lb < L + M[:, (Lb+1):L, b] .= 0f0 + end + + # 4) (policy) no pre-BOS insert (gap 1) + M[1:K, 1, b] .= 0f0 + end + return M +end + # Compute the remaining edits for the EditFlow as a Matrix function remaining_edits(P::EditFlow, Zt::Matrix{Int}, Z1::Matrix{Int}, Xt::Matrix{Int}, dense=false) padding_token = P.padding_token @@ -183,6 +250,52 @@ function remaining_edits(P::EditFlow, Zt::Matrix{Int}, Z1::Matrix{Int}, Xt::Matr end +# Drop-in replacement (renames ok): now returns (2K+1, L+1, B) +function remaining_edits_gapwise(P::EditFlow, Zt::Matrix{Int}, Z1::Matrix{Int}, Xt::Matrix{Int}) + K = P.k + PAD = P.padding_token + LAT = P.latent_token + + L, B = size(Xt) + ins = zeros(Float32, K, L+1, B) # gaps + sub = zeros(Float32, K, L, B) # sites + del = zeros(Float32, 1, L, B) # sites + + for b in 1:B + Ztb = Zt[:,b]; Z1b = Z1[:,b] + # real (site) tokens in Zt (BOS counts as real; PAD/LAT do not) + real = (Ztb .!= LAT) .& (Ztb .!= PAD) + sites_before = cumsum(real) # length(Ztb) + for r in 1:length(Ztb) + zt = Ztb[r]; z1 = Z1b[r] + # insert: LAT -> real + if zt == LAT && (z1 != LAT && z1 != PAD) + g = sites_before[r] + 1 # gap index in 1..L+1 + if 1 <= g <= L+1 + ins[z1, g, b] += 1 + end + # delete: real -> LAT + elseif (zt != LAT && zt != PAD) && (z1 == LAT) + s = sites_before[r] # site index in 1..L + if 1 <= s <= L + del[1, s, b] += 1 + end + # substitute: real -> real, different + elseif (zt != LAT && zt != PAD) && (z1 != LAT && z1 != PAD) && (zt != z1) + s = sites_before[r] + if 1 <= s <= L + sub[z1, s, b] += 1 + end + end + end + end + + # pad sub/del with a zero column at gap L+1 so we can vcat on channel axis + sub_pad = hcat(sub, zeros(Float32, size(sub,1), 1, size(sub,3))) + del_pad = hcat(del, zeros(Float32, size(del,1), 1, size(del,3))) + return vcat(ins, sub_pad, del_pad) # (2K+1, L+1, B) +end + @inline function pick_index(w::AbstractVector{<:Real})::Int # treat negatives as zero; assert we have some mass @@ -343,6 +456,40 @@ function edit_loss(P::EditFlow, return mean(term1 .- term2) end + +function edit_loss_gapwise(P::EditFlow, + M, transition_mask, edit_multiplier, scheduler_scaling; + op_mask=nothing, eps=1f-8) + + # 1) transform -> positiva satser + R = P.transform(M) + + # 2) kapa hastigheter för att undvika Inf/NaN i både term1 och log-delen + # (justera RMAX vid behov, 1e3–1e4 funkar ofta bra) + RMAX = 1f3 + R = clamp.(R, eps, RMAX) + + # 3) valfri op-mask + OM = isnothing(op_mask) ? one(eltype(R)) : op_mask + mask = transition_mask .* OM + + # 4) regularizer (sum av giltiga satser) + # -> per-batch summering: 1×1×B + term1 = sum(mask .* R; dims=(1,2)) + + # 5) data-del (log) – log säkert, redan kapat ovan + logR = log.(R) + scl = reshape(scheduler_scaling, 1, 1, :) + term2 = sum(scl .* (edit_multiplier .* OM) .* logR; dims=(1,2)) + + # 6) normalisera med "antal aktiva positioner" för stabil skala + active = sum(mask; dims=(1,2)) + loss_per_batch = (term1 .- term2) ./ (active .+ 1f-8) + + return mean(loss_per_batch) +end + + """ getlmask(P::EditFlow, Xt::AbstractMatrix{<:Integer}) @@ -351,4 +498,112 @@ Build lmask of shape (xt_length, B) from padded Xt. function getlmask(P::EditFlow, Xt::AbstractMatrix{<:Integer}) padding_token = P.padding_token return Xt .!= padding_token -end \ No newline at end of file +end + +# Utility: pick_index over nonnegative weights (1D) +@inline function _pick_index1d!(rng::AbstractRNG, cs::AbstractVector{<:Real})::Int + s = cs[end] + @assert isfinite(s) && s > 0 "pick_index: total mass ≤ 0 or non-finite" + u = rand(rng) * s + return searchsortedfirst(cs, u) +end + +# One CTMC Euler step over a single DiscreteState, using gap-wise insertions. +function step_gapwise( + P::EditFlow, + model, # your EditFlowModel (returns (2K+1, L+1, 1) logits) + Xt::DiscreteState{<:AbstractVector{<:Integer}}, + t1::Real, t2::Real; # times, with dt = t2 - t1 > 0 + rng::AbstractRNG = Random.default_rng(), + transform::Function = P.transform, +) + @assert t2 > t1 + x = collect(tensor(Xt)) # Vector{Int} + K = P.k + n = length(x) + + # Build masked state for the model + lmask = trues(n) # all real positions valid + cmask = trues(n) + Xt_ms = MaskedState(DiscreteState(K, reshape(x, :, 1)), reshape(cmask, :, 1), reshape(lmask, :, 1)) + + # Model forward (gap-wise head) + M = model([Float32(t1)], Xt_ms) # (2K+1, n+1, 1) logits + R = transform(M) # positive rates + ins = Array(R[1:K, :, 1]) # (K, n+1) + sub = Array(R[K+1:2K, 1:n, 1]) # (K, n) + del = vec(Array(R[2K+1, 1:n, 1])) # (n,) + + # Enforce CTMC constraints: no self-sub, protect BOS + if n > 0 && x[1] == P.bos_token + sub[:, 1] .= 0 + del[1] = 0 + # also disallow pre-BOS insert (gap 1) + ins[:, 1] .= 0 + end + # forbid self-substitutions + for i in 1:n + tok = x[i] + if 1 <= tok <= K + sub[tok, i] = 0 + else + sub[:, i] .= 0 # non-vocab token → block subs at site i + end + end + + dt = Float64(t2 - t1) + + # -------- sample site events (delete or substitute) -------- + to_delete = falses(n) + sub_to = zeros(Int, n) + for i in 1:n + r_del = max(del[i], 0.0) + r_sub_total = sum(@view sub[:, i]) + r_tot = r_del + r_sub_total + if r_tot > 0 && rand(rng) < (1 - exp(-dt * r_tot)) + u = rand(rng) * r_tot + if u < r_del + to_delete[i] = true + elseif r_sub_total > 0 + # draw new token from sub[:, i] + cs = cumsum(@view sub[:, i]) + sub_to[i] = _pick_index1d!(rng, cs) + end + end + end + + # -------- sample gap insertions (≤1 per gap) -------- + ins_tok = fill(0, n + 1) + for g in 1:(n + 1) + r_ins_total = sum(@view ins[:, g]) + if r_ins_total > 0 && rand(rng) < (1 - exp(-dt * r_ins_total)) + cs = cumsum(@view ins[:, g]) + ins_tok[g] = _pick_index1d!(rng, cs) + end + end + + # -------- build new sequence -------- + result = Int[] + if ins_tok[1] != 0; push!(result, ins_tok[1]); end + for i in 1:n + if !to_delete[i] + a = (sub_to[i] == 0) ? x[i] : sub_to[i] + push!(result, a) + end + if ins_tok[i + 1] != 0 + push!(result, ins_tok[i + 1]) + end + end + + return DiscreteState(Xt.K, result) +end + +# Convenience: multi-step simulate from t=0→1 with a schedule of times `ts` (sorted) +function rollout_gapwise(P::EditFlow, model, x0::DiscreteState, ts::AbstractVector; rng=Random.default_rng()) + @assert issorted(ts) && first(ts) >= 0 && last(ts) <= 1 + x = x0 + for k in 1:length(ts)-1 + x = step_gapwise(P, model, x, ts[k], ts[k+1]; rng=rng) + end + return x +end From 49447eca507a60ad580457b3c4e11d08168bfc1c Mon Sep 17 00:00:00 2001 From: Glowster Date: Tue, 4 Nov 2025 12:02:22 +0100 Subject: [PATCH 7/9] adding reparam model like they have in editflow example code --- editflow_code/analysis_notebook copy.ipynb | 1544 ++++++++ editflow_code/analysis_notebook.ipynb | 3724 +++++++++++++++---- editflow_code/editflowsrun.jl | 2 +- editflow_code/gapwise_notebook.ipynb | 2755 +++++++++----- editflow_code/helper_funcs.jl | 18 +- editflow_code/test/analysis_notebook.ipynb | 3753 ++++++++++++++++++++ src/editflows.jl | 450 ++- 7 files changed, 10544 insertions(+), 1702 deletions(-) create mode 100644 editflow_code/analysis_notebook copy.ipynb create mode 100644 editflow_code/test/analysis_notebook.ipynb diff --git a/editflow_code/analysis_notebook copy.ipynb b/editflow_code/analysis_notebook copy.ipynb new file mode 100644 index 0000000..166565f --- /dev/null +++ b/editflow_code/analysis_notebook copy.ipynb @@ -0,0 +1,1544 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m\u001b[1m Activating\u001b[22m\u001b[39m project at `~/dev/Flowfusion.jl/editflow_code`\n", + "\u001b[92m\u001b[1mPrecompiling\u001b[22m\u001b[39m project...\n", + " 2280.2 ms\u001b[32m ✓ \u001b[39mFlowfusion\n", + " 1 dependency successfully precompiled in 4 seconds. 470 already precompiled.\n", + "\u001b[32m\u001b[1m Resolving\u001b[22m\u001b[39m package versions...\n", + "\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `~/dev/Flowfusion.jl/editflow_code/Project.toml`\n", + "\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `~/dev/Flowfusion.jl/editflow_code/Manifest.toml`\n", + "WARNING: using StatsBase.sample in module Main conflicts with an existing identifier.\n" + ] + }, + { + "data": { + "text/plain": [ + "plot_len_dist (generic function with 1 method)" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using Pkg\n", + "Pkg.activate(@__DIR__)\n", + "Pkg.instantiate()\n", + "using Revise\n", + "\n", + "using Random\n", + "using Statistics\n", + "using Adapt\n", + "using Functors\n", + "using Flux\n", + "using Onion\n", + "using RandomFeatureMaps\n", + "using Zygote\n", + "\n", + "Pkg.develop(path=joinpath(@__DIR__, \"..\"))\n", + "using Flowfusion\n", + "const FF = Flowfusion\n", + "\n", + "include(joinpath(@__DIR__, \"prob_model.jl\"))\n", + "include(joinpath(@__DIR__, \"helper_funcs.jl\"))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "to_same_device (generic function with 1 method)" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import CUDA\n", + "\n", + "# Device helpers\n", + "const _gpu_enabled = try\n", + " CUDA.has_cuda()\n", + "catch\n", + " false\n", + "end\n", + "\n", + "to_dev(x) = _gpu_enabled ? Adapt.adapt(CUDA.CuArray, x) : x\n", + "to_cpu(x) = _gpu_enabled ? Adapt.adapt(Array, x) : x\n", + "# move x to the same device type as y (Array or CuArray)\n", + "to_same_device(x, y) = (_gpu_enabled && (y isa CUDA.CuArray)) ? Adapt.adapt(CUDA.CuArray, x) : Adapt.adapt(Array, x)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "make_minibatch (generic function with 1 method)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Minibatch builder (uses true PM)\n", + "function make_minibatch(B::Int, P::FF.EditFlow; rng=Random.default_rng())\n", + " K = P.k\n", + " x0s = Vector{FF.DiscreteState}(undef, B)\n", + " x1s = Vector{FF.DiscreteState}(undef, B)\n", + " for b in 1:B\n", + " # x1 from true PM\n", + " seq1 = sample(PM; rng=rng)\n", + " @assert all(1 .<= seq1 .<= K)\n", + " x1s[b] = FF.DiscreteState(K, seq1)\n", + " # x0: uniform tokens with random length in 1:10 (no BOS in x0)\n", + " L0 = rand(rng, 1:10)\n", + " seq0 = rand(rng, 1:K, L0)\n", + " x0s[b] = FF.DiscreteState(K, seq0)\n", + " end\n", + " ts = rand(rng, Float32, B)\n", + " return x0s, x1s, ts\n", + "end\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "EditFlowModel" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Model definition\n", + "struct EditFlowModel{L}\n", + " layers::L\n", + "end\n", + "Flux.@layer EditFlowModel\n", + "#=\n", + "function EditFlowModel(; d=128, num_heads=8, nlayers=6, rff_dim=128, cond_dim=128, K::Int)\n", + " embedding = Flux.Embedding(K + 2 => d)\n", + " time_embed = Flux.Chain(RandomFourierFeatures(1 => rff_dim, 1.0f0), Dense(rff_dim => cond_dim))\n", + " blocks = [Onion.AdaTransformerBlock(d, cond_dim, num_heads) for _ in 1:nlayers]\n", + " head_combined = Dense(d => 2K + 1, bias=false)\n", + " rope = RoPE(d ÷ num_heads, 4096)\n", + " return EditFlowModel((; embedding, time_embed, blocks, head_combined, rope, K))\n", + "end\n", + "=#\n", + "function EditFlowModel(; d=128, num_heads=8, nlayers=6, rff_dim=128, cond_dim=128, K::Int)\n", + " embedding = Flux.Embedding(K + 2 => d)\n", + " time_embed = Flux.Chain(RandomFourierFeatures(1 => rff_dim, 1.0f0), Dense(rff_dim => cond_dim))\n", + " blocks = [Onion.AdaTransformerBlock(d, cond_dim, num_heads) for _ in 1:nlayers]\n", + " head_combined = Dense(d => 2K + 1, bias=false)\n", + " ins_q = Dense(d => K, bias=false)\n", + " sub_q = Dense(d => K, bias=false)\n", + " ins_lambda = Dense(d => 1, bias=false)\n", + " sub_lambda = Dense(d => 1, bias=false)\n", + " del_lambda = Dense(d => 1, bias=false)\n", + " rope = RoPE(d ÷ num_heads, 4096)\n", + " return EditFlowModel((; embedding, time_embed, blocks, head_combined, rope, K))\n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Forward pass\n", + "function (model::EditFlowModel)(t, Xt_ms)\n", + " m = model.layers\n", + " X = FF.tensor(Xt_ms)\n", + " X = ndims(X) == 1 ? reshape(X, :, 1) : X\n", + " L, B = size(X)\n", + "\n", + " pmask = Zygote.@ignore FF.getlmask(Xt_ms)\n", + " Xp = X .+ 1\n", + " println(\"min/max X: \", minimum(X), \" / \", maximum(X), \" pad=\", P.padding_token, \" lat=\", P.latent_token)\n", + " @assert all((0 .<= X) .& (X .<= P.padding_token))\n", + " \n", + " H = m.embedding(Xp)\n", + "\n", + " t = ndims(t) == 0 ? fill(Float32(t), B) : Float32.(t)\n", + " cond = m.time_embed(reshape(t, 1, B))\n", + "\n", + " cond = to_same_device(cond, H)\n", + " pmask = Zygote.@ignore to_same_device(pmask, H)\n", + " rope = Zygote.@ignore to_same_device(m.rope[1:L], H)\n", + "\n", + " for blk in m.blocks\n", + " H = blk(H; cond, rope, kpad_mask=pmask)\n", + " end\n", + "\n", + " ins_head = m.ins_q(H)\n", + " sub_head = m.sub_q(H)\n", + " lambda_ins = m.ins_lambda(H)\n", + " lambda_sub = m.sub_lambda(H)\n", + " lambda_del = m.del_lambda(H)\n", + " return (ins_head, sub_head, lambda_ins, lambda_sub, lambda_del)\n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "# Forward pass\n", + "function (model::EditFlowModel)(t, Xt_ms)\n", + " m = model.layers\n", + " X = FF.tensor(Xt_ms)\n", + " X = ndims(X) == 1 ? reshape(X, :, 1) : X\n", + " L, B = size(X)\n", + "\n", + " pmask = Zygote.@ignore FF.getlmask(Xt_ms)\n", + " Xp = X .+ 1\n", + " #println(\"min/max X: \", minimum(X), \" / \", maximum(X), \" pad=\", P.padding_token, \" lat=\", P.latent_token)\n", + " #@assert all((0 .<= X) .& (X .<= P.padding_token))\n", + " mX = Zygote.@ignore maximum(X)\n", + " nX = Zygote.@ignore minimum(X)\n", + " @assert (0 <= nX) && (mX <= P.padding_token)\n", + "\n", + " \n", + " H = m.embedding(Xp)\n", + "\n", + " t = ndims(t) == 0 ? fill(Float32(t), B) : Float32.(t)\n", + " cond = m.time_embed(reshape(t, 1, B))\n", + "\n", + " cond = to_same_device(cond, H)\n", + " pmask = Zygote.@ignore to_same_device(pmask, H)\n", + " rope = Zygote.@ignore to_same_device(m.rope[1:L], H)\n", + "\n", + " for blk in m.blocks\n", + " H = blk(H; cond, rope, kpad_mask=pmask)\n", + " end\n", + " return m.head_combined(H)\n", + "end\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "train_editflow! (generic function with 1 method)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Training (GPU if available)\n", + "function train_editflow!(P::FF.EditFlow,\n", + " model;\n", + " epochs::Int=1,\n", + " steps_per_epoch::Int=100,\n", + " batch_size::Int=64,\n", + " lr::Float32=1f-2,\n", + " seed::Int=42,\n", + " print_every::Int=25)\n", + "\n", + " rng = Random.MersenneTwister(seed)\n", + " Random.seed!(seed)\n", + "\n", + " # Move model to device (GPU if available)\n", + " model = Functors.fmap(to_dev, model)\n", + " opt_state = Flux.setup(Flux.Adam(lr), model)\n", + "\n", + " for epoch in 1:epochs\n", + " for step in 1:steps_per_epoch\n", + "\n", + " # 1) Minibatch Sampling\n", + " x0s, x1s, ts = make_minibatch(batch_size, P; rng=rng)\n", + "\n", + " # 2) Align and batch\n", + " Z0, Z1 = FF.align_and_batch(P, x0s, x1s)\n", + "\n", + " # 3) Interpolate\n", + " Zt, Xt = FF.interpolate_Z_elementwise(P, Z0, Z1, ts)\n", + "\n", + " # 4) Prepend BOS\n", + " bos = P.bos_token\n", + " Zt = vcat(fill(bos, 1, batch_size), Zt)\n", + " Xt = vcat(fill(bos, 1, batch_size), Xt)\n", + " Z1 = vcat(fill(bos, 1, batch_size), Z1)\n", + " \n", + " # 5) Masks and multipliers\n", + " transition_mask = FF.transition_mask_from_Xt(P, Xt)\n", + " edit_multiplier = FF.remaining_edits(P, Zt, Z1, Xt)\n", + " @assert size(transition_mask) == size(edit_multiplier)\n", + "\n", + " # 6) Scheduler scaling\n", + " den = 1f0 .- P.κ.(ts)\n", + " den = max.(den, 1f-3)\n", + " scheduler_scaling = P.dκ.(ts) ./ den\n", + "\n", + " # 7) Masked state\n", + " lmask = Xt .!= P.padding_token\n", + " cmask = trues(size(lmask))\n", + " Xt_ms = FF.MaskedState(FF.DiscreteState(P.k, Xt), cmask, lmask)\n", + "\n", + " ts_d = to_dev(ts)\n", + " Xt_ms_d = to_dev(Xt_ms)\n", + " Tmask_d = to_dev(transition_mask)\n", + " Emult_d = to_dev(edit_multiplier)\n", + " sched_d = to_dev(reshape(Float32.(scheduler_scaling), 1, 1, :))\n", + "\n", + " # 8) Forward + loss + update\n", + " loss, grad = Flux.withgradient(model) do m\n", + " M = m(ts_d, Xt_ms_d)\n", + " l = FF.edit_loss(P, M, Tmask_d, Emult_d, sched_d; eps=1f-8)\n", + " if isnan(l)\n", + " println(\"Maximum element of M: \", maximum(M))\n", + " end\n", + " l\n", + " end\n", + " Flux.update!(opt_state, model, grad[1])\n", + "\n", + " if step % print_every == 0\n", + " @info \"train\" epoch step loss=Float32(loss)\n", + " end\n", + " end\n", + " end\n", + "\n", + " return Functors.fmap(to_cpu, model)\n", + "end\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# Init process and model\n", + "K = PM.K\n", + "P = FF.EditFlow(K; bos_token=0, impl=\"positionwise\")\n", + "model = EditFlowModel(; d=128, num_heads=8, nlayers=4, rff_dim=128, cond_dim=128, K=K)\n", + "nothing" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 81.5171f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 63.493782f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 59.012363f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 58.97118f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 50.419544f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 51.323597f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 51.624657f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 48.713852f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 49.294586f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 52.53109f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 46.66154f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 46.56837f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 49.605583f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 47.38654f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 44.482132f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 48.082584f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 45.253014f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 43.067787f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 42.395924f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 42.587074f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 41.693085f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 42.755257f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 43.976986f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 40.780937f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 42.15659f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 39.584618f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 40.946358f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 42.274662f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 41.849945f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 41.614258f0\n" + ] + }, + { + "data": { + "text/plain": [ + "EditFlowModel(\n", + " Embedding(22 => 128), \u001b[90m# 2_816 parameters\u001b[39m\n", + " Chain(\n", + " RandomFourierFeatures{Float32, Matrix{Float32}}(Float32[8.529786 1.4104536 … 0.28503644 -7.469009]),\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " [\n", + " TransformerBlock(\n", + " Attention(\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " identity,\n", + " identity,\n", + " Onion.var\"#32#34\"(),\n", + " 16,\n", + " 16,\n", + " 8,\n", + " 8,\n", + " ),\n", + " StarGLU(\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(512 => 128; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " NNlib.swish,\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9927389, 0.995017, 0.99550515, 0.9944197, 0.9924084, 0.9989874, 0.99385405, 0.9942679, 1.0000424, 1.0037912 … 0.9942788, 0.99082935, 0.9904582, 0.9915918, 0.9994775, 0.99774563, 0.99622786, 0.99355125, 0.98682874, 0.9916295], Float32[-0.0058128564, -0.0014852639, 0.0017711775, 0.0025712461, -0.0038710728, 0.0016847431, 0.0028967822, 0.003991662, -0.0015246351, -4.6463974f-5 … 0.0006014786, -0.0023472367, -0.0023561758, 0.0006260582, 0.0022964154, 0.0005220497, -0.0015367864, -0.0010421762, -0.0013536707, -0.000992959], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9972253, 0.99951667, 0.9969008, 0.9992949, 0.98925614, 0.9973548, 0.9966963, 1.0072627, 1.0053163, 0.99864525 … 1.0076041, 0.9989389, 0.99891305, 0.9896608, 0.9973922, 1.0018995, 0.9994337, 1.0012733, 1.0044928, 0.99932957], Float32[-0.0020217572, 0.00045662682, 0.0037664024, 0.0031012846, -0.0027788132, -0.0036462964, 0.0027171317, 0.0037337039, -0.0019016194, 0.001187094 … 0.0007999025, 0.0010091417, -0.0004998848, -0.00046192663, -0.0009970615, 0.0010046392, -0.0013360388, -0.00071286794, -0.0017081661, -0.0023509015], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " identity,\n", + " ),\n", + " TransformerBlock(\n", + " Attention(\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " identity,\n", + " identity,\n", + " Onion.var\"#32#34\"(),\n", + " 16,\n", + " 16,\n", + " 8,\n", + " 8,\n", + " ),\n", + " StarGLU(\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(512 => 128; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " NNlib.swish,\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9937645, 0.9900202, 1.0001692, 0.99522585, 0.9978626, 0.9951527, 0.9973957, 0.99491405, 0.9904468, 0.99554497 … 0.9967526, 0.9979659, 0.99347985, 0.9954838, 0.99880844, 0.99987525, 0.9969922, 0.9964722, 1.0026605, 0.9961422], Float32[-0.0030214672, -0.00076218136, 0.0021669136, -0.000539773, -0.00023664715, -0.0012380814, 0.00011221414, -0.0050113825, -0.00034657144, 0.002786954 … 0.0015049657, -0.0019077003, -0.0015806447, 0.0021096128, -0.0047903364, 0.0013625681, -0.001690899, 0.0019822896, -0.0033150173, 0.0020150973], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.99748296, 1.0048722, 0.99336493, 1.001614, 0.9965636, 0.99819463, 0.99690235, 1.0005269, 0.9995311, 0.9954543 … 0.99206907, 1.0004294, 1.0084617, 1.0007285, 1.0030751, 1.0050168, 1.0015122, 1.0002509, 0.9992035, 0.9950786], Float32[-0.00090104516, -0.0003761406, -0.0008079005, 0.0015836438, -0.0008108232, 0.0013318892, 0.0005486783, -0.002771887, 0.0011146952, 0.0041731894 … -0.0013222725, -0.0013798344, -0.0010058298, 0.0017525654, 0.00043384888, 0.0025286146, 0.00349777, 3.1624797f-5, 0.00017443944, -0.0033164807], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " identity,\n", + " ),\n", + " TransformerBlock(\n", + " Attention(\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " identity,\n", + " identity,\n", + " Onion.var\"#32#34\"(),\n", + " 16,\n", + " 16,\n", + " 8,\n", + " 8,\n", + " ),\n", + " StarGLU(\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(512 => 128; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " NNlib.swish,\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9999873, 1.0007596, 1.0004652, 0.9980036, 0.99611694, 0.99963504, 0.99828976, 0.9941192, 0.99682456, 1.0036113 … 0.9962207, 0.99932814, 1.0052634, 0.99965405, 0.99797845, 1.0021533, 0.99630314, 0.9962363, 0.9968872, 0.9950752], Float32[0.0016285058, 0.0010424233, 0.0014664369, -0.0014162131, 0.0017848933, 0.000904849, 0.00092839357, -0.0016400279, -0.001116365, -0.0033237175 … -0.00095372245, 0.001379597, -0.0012153891, 0.0021411562, -0.0018140029, 2.6796373f-5, 0.00015037494, -0.0011084817, -0.0011156661, 0.00032005878], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[1.0022401, 0.9986023, 1.0036827, 1.0028428, 1.000628, 1.0002831, 1.0026282, 0.99865013, 1.0008336, 1.0011939 … 1.0003446, 0.99899316, 1.002376, 1.0019797, 0.99698734, 0.999672, 1.0006473, 1.0076064, 0.99772197, 0.9987918], Float32[0.00015093086, 0.0012914928, -0.003335636, 0.0020593128, 0.0022943593, -0.002442357, 0.002647567, -0.0009951793, 0.0038749017, 0.0015201706 … -0.00042401845, 0.0010297338, -0.0010947591, 0.0017330695, -0.0038933319, 0.0008850007, -0.0018997401, -0.0021773023, -0.0017003756, -0.0052421563], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " identity,\n", + " ),\n", + " TransformerBlock(\n", + " Attention(\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " identity,\n", + " identity,\n", + " Onion.var\"#32#34\"(),\n", + " 16,\n", + " 16,\n", + " 8,\n", + " 8,\n", + " ),\n", + " StarGLU(\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(512 => 128; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " NNlib.swish,\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9968295, 0.99981964, 0.997613, 1.0026582, 1.0021008, 0.9980333, 0.9980151, 1.0059716, 0.9994964, 1.0015678 … 1.0007763, 1.0008732, 0.9982152, 0.996613, 1.009945, 1.0004773, 0.99887973, 0.99991816, 1.0020856, 1.0039768], Float32[-0.002375596, 0.0017580708, 0.0015227637, 0.002731847, -0.0018972742, 0.0016495208, 0.0021964826, 0.0021700887, -0.008651828, -0.0018713331 … -0.0012924711, -0.002237556, 0.0030750209, -0.0023795986, 0.0026068965, -0.0046221926, 0.0015926374, -0.0025060303, 0.002212718, -0.0010806752], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[1.0013795, 0.9984948, 0.9960571, 1.0029256, 1.0054785, 1.004133, 0.9986023, 1.0040288, 1.0013745, 1.0022346 … 0.99479765, 1.0003234, 1.0026337, 1.0049077, 0.99656516, 0.9970753, 1.0004745, 0.99843496, 0.9936143, 0.99871683], Float32[0.0003255698, 0.0014144776, -0.0015200237, -0.0031796026, -0.0032191605, -0.002849132, 0.0020276716, 0.0025240814, -0.0016611946, -0.0017054722 … -0.003542002, 0.0001635102, -0.0026410683, -0.0013011089, -0.001919553, -0.0027726274, 0.0012582649, -0.0031571249, 0.0023577497, 0.0023878366], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " identity,\n", + " ),\n", + " ],\n", + " Dense(128 => 41; bias=false), \u001b[90m# 5_248 parameters\u001b[39m\n", + " RoPE{Matrix{Float32}}(Float32[1.0 0.5403023 … -0.87528455 -0.065975994; 1.0 0.95041525 … 0.9552474 0.8159282; … ; 1.0 0.9999995 … -0.57972294 -0.5789079; 1.0 0.99999994 … 0.2726629 0.27235872], Float32[0.0 0.84147096 … -0.48360822 -0.9978212; 0.0 0.3109836 … 0.29580808 0.5781532; … ; 0.0 0.0009999999 … -0.8148137 -0.8153929; 0.0 0.0003162278 … 0.9621096 0.9621958]),\n", + " 20,\n", + ") \u001b[90m # Total: 80 trainable arrays, \u001b[39m1_339_392 parameters,\n", + "\u001b[90m # plus 3 non-trainable, 65_600 parameters, summarysize \u001b[39m5.364 MiB." + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model = train_editflow!(P, model; epochs=5, steps_per_epoch=150, batch_size=256, lr=1f-4)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Sampling and Levenshtein plot\n", + "using Random\n", + "n = 1000\n", + "# 100 model samples (final states → strings)\n", + "model_samples_any = sample_gen_n(P, model; n=n, ts=0f0:0.01f0:1f0, rng=Random.MersenneTwister(42))\n", + "model_final_states = map(final_state_from_gen, model_samples_any)\n", + "model_strings = [state_to_PM_string(P, s) for s in model_final_states]\n", + "\n", + "# Build training strings from PM parents (the data PM was built on)\n", + "train_states = [FF.DiscreteState(P.k, sample(PM; rng=Random.MersenneTwister(1000+i))) for i in 1:100]\n", + "train_strings = [state_to_PM_string(P, s) for s in train_states]\n", + "\n", + "# Independent validation strings sampled from PM\n", + "val_states = [FF.DiscreteState(P.k, sample(PM; rng=Random.MersenneTwister(1000+i+2*n))) for i in 1:n]\n", + "val_strings = [state_to_PM_string(P, s) for s in val_states]\n", + "#val_strings = [s for s in val_strings if !(s in train_strings)]\n", + "\n", + "# Plot normalized Levenshtein vs. training set (distinct val/train)\n", + "plt = plot_lev_dist(\"model_vs_true\", val_strings, model_strings, train_strings; title=\"Model vs True (normalized Levenshtein)\")\n", + "display(plt)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model_strings_bos = [\">\" * state_to_PM_string(P, s) for s in model_final_states]\n", + "plt = plot_lev_dist(\"model_vs_true\", val_strings, model_strings_bos, train_strings; title=\"Model vs True (normalized Levenshtein)\")\n", + "display(plt)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlgAAAGQCAIAAAD9V4nPAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nOzdd2AT5f8H8CejK917QUtZpVD23i0gG9niqixlyxARFUSm8oUvQxAZyhJBGSpD9hRooRRKgbZA6Z7pntnjfn+c3/vF9FrS0qQp9379lTy3PrmMd+7uuTseRVEEAACAq/j1XQAAAEB9QhBy1/Lly2fOnFmHuwQOHz48c+bMp0+fMi1LliyZNWtWXc2f1a5du6ZPn56Wlsa0zJ0797PPPjPqQgkhFy9enD59+t9//23sBXHQ8ePHp0+fHh0dXd+FEEJIXl5eTExMeHj4kydPlEplfZdjvjIzM2fOnLlr1676LqRWKKgjWVlZFhYW7u7u9V2Ivr179x48eLBye7NmzQghGo2mrhZEZ96lS5eYFl9fX0tLS8Pn8OLFi927d9+7d8/wSSZOnEgIuX//PtNiZWXl7e1t+Byqd+PGjd27d2dlZem1b9iwgRCyc+fOulpQ7dy/f5/+Irdv377yWzlgwABCyI0bN2o0T6lUunv37j///LPuyqyZTz/9lBDy+++/11cBFEVJpdLNmze3atVK99fS0tJy8ODBR48ercNvTb0IDw/fvXt3ampqHc4zJiaGEDJu3Lg6nKfJCE2auq81iqJUKpUZ/mecP3++SCT64IMPTL/oXr16lZaWGj7+vXv3Zs6cuWzZsq5duxo4SXBwcH5+vr29fa0KfLmDBw/u37//2rVrPj4+uu1+fn4hISG+vr5GWm5NPXr06MSJE2+99darz6q8vHzmzJndunUbM2bMq8+tIcrOzh41alR0dLSNjc2YMWM6dOhgbW1dUlJy9+7da9euXbp06Ztvvvniiy/qu8zaO3r06LZt206dOuXv71/ftZgFBCEY0bFjx4y9iBUrVqxYscLYS6ls0qRJkyZNMv1yWTk7O5eUlHz11Vfjxo0TCvGlfiVyufzNN9+Mjo4eOHDgoUOHvL29dYempKQsW7ZMLpfXV3lgDPjO1IOCgoIrV65kZ2fb2Nj07NmzQ4cOukNLSkqSkpI8PDwaN26cnp5+6dKlsrKywMDAwYMHW1hY6M1KpVJdvnz5+fPn9vb2AwcODAgISE1NLSwsDAwMtLOzKy4uTk5O1mq1arX6wYMH9CT29vYtW7bUnYlSqbx48eKLFy8cHR0HDx7cuHFjQ16FVqu9evVqbGysnZ1daGho8+bNK4/z5MkTtVrdsWNH3caHDx/GxcWJxWJnZ2dfX98+ffrY2dkRQl68eJGSkkIIycnJYaoNCAhwcXEpLy9PSEhwc3Pz9/fPzMy8cuVKfn7+6NGjW7ZsmZKSUlRUFBQUJBKJ9JZeWlp67ty57OxsX1/f4cOHOzg46A599OgRRVF6K7+0tDQxMZFe+YSQ6OjogoICQkhCQgIzebt27SwsLHJzczMzM/39/d3c3HTnQL+5WVlZdnZ2PXr0aN++ve5QtVr96NEjkUgUFBRUWlp69uzZ7OzsRo0aDR061MnJyZDVzqply5Y+Pj5//vnn/v37P/roo+pHrqioCA8Pz8jIKCkp8fHxCQ0N1f2tz83Nffz4MSFEIpEw74Krq2uTJk2USuWTJ08qf35ycnKys7N1V0VcXJxcLu/UqRP9+Xzx4oWPjw+ztfr06dPHjx9nZ2dbWFi0a9euT58+fH7NOivQS/Tx8dFLKWaQr6+vl5cX3ZKcnPzgwYPMzExra2tvb++ePXt6enpWM/Pdu3c/ePCgVatWZ86csbGx0RsaEBBw5MgRsVis105R1IMHD+7fv19RUeHn5/fGG284OzvrjpCQkFBeXt62bVuhUHj16tW4uDhra+sBAwborUyaVqu9c+dOTEyMQqEICAh444036O8Iw/A13LZt2759++qu4ZiYmLy8PEJIUlIS8xYHBwdbWVkx4zx8+PDevXvl5eWNGjV64403XF1dKxeZmpp68eJFuVzeqlWrQYMGVbNKG4B63jX7GsnMzCSEODo6VjOORqNZsWKFtbW17lswcuTIkpISZpyTJ08SQhYsWLB+/XqBQMCM1r59+9zcXN25JSUltW7dmhmBz+evWrVq8uTJhJBbt25RFHXixInK73j//v3pyeljhLGxsS1atGCGWlpaHjhw4KUvNicnp1u3bsxUPB5v2bJlLz1GWFxcPHDgQL166FChKGro0KGVqz106BBFUVeuXCGETJ8+/ZtvvmHWyf79+6mqjxFeuHBBN1rc3d2vXr2q+xJcXV2dnJz0Xtdff/1FCJk/fz79VHf9M8RiMVXFMcLNmzfr5fHQoUMLCwuZEfLz8wkhXbp0OXfunG55bm5ukZGRurOKiIiYM2fOli1bqn8j6GOE3bt3f/bsmVAo9PHxkUgkzNDKxwi//vpr3d87+h1fsWIFM8LGjRsrv+QpU6ZQFEX3SAoNDdWrYe3atYSQvXv3Mi2BgYH0m9K0aVN6Dt26daMoSiwWBwQE6M28devW8fHxujN86TFC+vMwfPjwyoOGDBlCCLl+/TpFURqNZu7cuTweT3dxPB7v7Nmz1axSuviff/65mnH0vHjxonv37rpLcXBw0PsehYSEEEIiIiK6dOnCjMbn87/99lu9uUVHRwcHB+vOzc3N7fTp05WLjIqKYtZw165dKYrKzc1lWhhBQUG6a5j1L1dCQgI9NCUlpU+fPrqD7Ozs9uzZo1fkmjVrdPc9tG/fnv7uNNBjhAjCOmNIEC5evJgQ0qZNm6NHj8bHx9+8eXPcuHGEkKFDhzLj0EEYEBDg6Oi4ZcuWe/fuXbx4sWfPnoSQsLAwZjSZTEYfyZ8+ffqjR4/S09P37t3r5OREH8qigzA3N/fy5cvW1taOjo6X/4fJDDoIAwICxo0bd+HChaioqFWrVgmFQmtr64yMjGpehVqt7tGjByFkwoQJDx48SEtL27Nnj4ODA73oaoJwzpw5hJCJEydGRESkp6c/fvz42LFj48ePp4MwOjqaPu7y7rvvMtXm5ORQ//vh8/Pzs7OzW7NmzdWrVy9dukRv0rEGoa2traOj44IFC+Lj45OSktauXSsQCGxtbZOTk5nRDAnCK1eu0D+s//3vf5mSFAoFxRaEu3fvJoR4eHgcPHjwxYsXt27deuONNwghPXv2VKlU9Dh0EHp6etrb2y9evPjGjRu3b9+m/7s0b95ctwvGTz/9RAjp169fNW8EpROEFEVNmTKFELJhwwZmaOUgnDNnzuzZs0+fPh0bGxsbG7tv374mTZoQQpjuVKmpqcePHyeEBAYGMi85NjaWqnkQ+vn5jR49+tixYxERESdPnqQoKjk5uWvXrt9///2tW7devHhx8+bNDz/8kBDSrFkzeq3SXhqEWq02ICBAIBBkZ2frtmdlZQkEgiZNmtBr8ueff6YT4vz582lpaU+fPj1//vysWbMuX75c1Zyzs7PpsMzPz69mtevKycnx9vYWCARz5sy5devW06dPDxw44OnpyePxzp8/z4xGB2FAQEBoaOjp06cfPHiwdetWkUjE5/MfPHjAjEbve7C0tFy6dOmdO3diY2N/+OEHR0dHCwuLqKioymv4zTffpNcw3bkpJSWFWcOJiYk3b96k9xDoruHr16/TR39Xr17NvMX0/6f8/Hw/Pz8+n//RRx/9/fffz549++WXX+gD4bqdp/bv308I8fX1PXHiRHp6enh4eN++femvP4KQ614ahE+ePOHxeM2aNSsvL9dtp/cq0P9hqf8FIY/Hi4iIYMbJy8sTiUQikUir1dIte/bsIYQMGTJEd1ZHjx6l/6DRQUiztbVl7ctKB+GkSZN0G2fMmEEI2bVrVzWvlN7Q7NKli+4P95EjR+hFVxOErVq1srS01P3J03P48GFCyLJly/Ta6SAkhJw4cUJvEGsQ0mmqO9ry5csJIVOnTmVaDAlCiqKmTp1KCLl27ZremHpBKJVK6d1Hf//9NzOOQqEICgoihBw5coRuoYOQELJp0yZmNK1WS++h1f1B3Lt3L4/HCwkJqbyWdOkGYWpqqpWVlbOzc1FRET3UkF6jCQkJFhYWnTp1Ylpyc3PJ/7bhdNU0CAcNGsR8XKsxffp0Qsgff/zBtBjSa/Srr74ihGzcuFG3cf369YSQr7/+mn5K/zO4e/fuS2tghIeHE0Lc3NwMn2TatGmEEL0Nu+joaIFA0KFDB6aFDsI+ffrofmvWrFmj94EfPnw4+d/eDsbFixf1/i7XaA3T/zZ01+f8+fMJIadOndIbc+7cuYQQ3T0EFEXFxcVZWFi0atWKfqpSqejM012xEomkQQchziM0nV9++YWiqAULFujt7p89ezYh5Ny5c7qNffv2pbcCae7u7h07dpRKpfSPFCHk9OnThJCFCxfqTjVhwgQDj/AxlixZovuU3oihj9VVhY7qRYsW6R54eOutt/z8/KpflrOzs0qlYg5L1FSLFi3oDWhD0BvfjPnz5wuFQvpfbe2WXr2bN28WFhb26tWrX79+TKOlpSVdxh9//KE7srW19ccff8w85fF4gwcPJv9e7dOmTdNqtdevXze8Bn9//9mzZxcXF2/atMnwqVq0aBEUFPTo0SOFQmH4VIb47LPP9HZLsho9ejQh5N69ezWa+dSpU3k83oEDB3Qbf/nlFx6PFxYWRj+l9wHeuXPH8NnSnZwrd0I+evToGzqYflIqlero0aMikeiTTz7RHb9jx449e/aMiYnJycnRbV+8eLHut0bv61ZQUHD+/PlGjRrREc4YPHhw8+bNr1+/rtdJZ8mSJXW4hrVa7ZEjR+iNUd321q1bh4SEPHv2LDk5mRASGRmZnZ3dp08f3b3BIpGI/h1roNBZxnQePnxICLlz505WVpZuO33gPTU1VbeR/seniz7Cn5ubS/cCSEhIIIToHiMkhPD5/KCgoIyMDMOr0lsQvZTKfQF0xcfHE0L0uoEIBIK2bdump6dXM+G0adPu3LnTp0+fkJCQQYMGDRw4sEuXLoZ3lAgKCjLka08I4fP5bdu21W1xd3dv1KhRampqVlZWo0aNDFyi4ejLCHTq1EmvvXPnzoSQuLg43camTZvq9Xti3txXLGPZsmX79u3bunXrvHnzmN4iulQq1c6dO48dO5aSkpKbm6vRaJhBJSUl1fciqak2bdpUboyNjd2wYcP9+/czMzPLy8uZdrpTkuECAgL69Olz69atBw8e0Cs5KioqNjY2JCSE3tVBCAkLC/v+++8XLVp08ODBoUOHhoaG9u/fX+8QqR5bW1tCiEwm02sXi8X0HzitVltaWsp00klISJBIJJ6enpW7LhcXFxNCUlNTdXv0VP91i4mJoSjK0tLy888/15ubWq1WKBQ5OTm6B1lZ13BcXNx//vOfWqzh1NTU4uJiV1fX1atX6w2iO9ekpqY2bdqU9etPCNHrd9awIAhNp6SkhBBy9uzZyl0wnJ2d9Ror94GkA0Or1dJP6e9q5ePeNe18qLcgeinVbzZVVFQQQtzd3fXaK7fo+fDDDx0dHTdv3nzjxo1r164RQnx8fNavX8/8ha+eXv/Majg5OVXuYevh4ZGamqr701CH6Nl6eHhUXigzlFH5zaUDnnlza83NzW3RokWrVq1at27d9u3b9YZSFDV27NizZ8/6+/u/+eabnp6edK/I3bt3p6SkqNXqV1x65WL0WiIiIgYNGqRWq0NDQ0eNGuXs7Mzj8VJSUnbv3q0byQaaPHnyrVu3Dh48SAfhwYMH6UZmhE6dOkVERKxcufLq1asxMTHr16+3t7dftGjR8uXLK388aPSfpPz8/IqKCt09NwsWLFiwYAEhJC0tjT6qSqO/1EVFRfShCj30LhDdluq/bvTcsrKyqpqb3lZ7NWs4JCSkpmuYXnppaWn1r6Wqr3/lD38DgiA0Hfp7dfLkydDQ0Fefm7Ozc0ZGRnZ2tt5ZAfTRfqOiX0heXp7eR5/+21i9iRMnTpw4MT8//8aNG3/99ddvv/32wQcfODs7jxw58qXTGrg5SAgpKSlRKpWWlpa6jfT2FrO6+Hy+3o8UIUQikRi4CD30bCuvAb2FmsCnn366c+fO3bt36+02J4TcuHHj7NmzvXv3vnr1qu6G0b59+wyZM/2rXfn31PCVtnz5cplMdvLkSXpnHe348eN0P6OamjRp0sKFC48cObJx40Yej3f06FFbW9vx48frjtO1a9ezZ8/SZ4xcunRp3759q1evpiiq8kYPrWnTpj4+PtnZ2Tdu3DDkM0nvRG3Tpg29v+cV0XMLDQ09f/587ebw1VdfyWSyP//8U/diCAauYXrpzZo1e/bs2UtHq+qj3kDhGKHp0KfT0UfjXx29F07vWpfFxcX0hY50WVhY1O2ffbpvt943nz5DzsA5uLu7T5w48eDBg/RWy++//86USs/qFSvUarV66yE3NzcrK8vFxYW5QIyXl1dZWZneTjB6t48uuqSX/pumd1IxFzxjREVFEUL09tMalZ2d3eeff65SqVatWqU3iF4nY8eO1U3B4uJivUPCVb0LHh4efD6/8u+d7tVlq/fo0SNbW9s333xTt7HWx4zt7OzGjh1bWFh47ty506dPFxQUTJw4kfUaQ3Z2dkOGDNm0adONGzcIIaynFTHo43MbN240ZAM9MDBQJBLFxcXV6ApKVenQoQOPx4uKiqr8F81A9FmqL13DrJ/qpk2bOjo6vnjxgunSxYr+qFcOfjO5NmztIAhNZ8qUKXw+//vvv9c7RkgI0Wq1Uqm0RnOjdwFt2LCBPhRBW7t2Lb3jQpevr29paWkd7hKke6xs2bJF94v066+/Vn5deirXRh8+YXb40B21a3SMsyp6HUa2bt2qVqvHjx/PbFbSx1p0/3oXFxdXvmQwHZwvLalv374eHh53796lf2ppcrl88+bNhBC6a2uNxMfHb9u2Ta+XjYFmz57t5+d3+PBh+kAyg96dpXccd82aNXo/u87OziKRKCsrSy8JLC0tGzVqlJiY+OLFC6bxyZMndFdbQ7i7u8tkMt2NCbFYvHPnTgMnr4z+Fhw8eLDyflHC9nmj383quwUtWrTI19f35s2b8+fPf+l/Misrq3feeUelUtG9WPVULqB6np6ew4cPLywsZD2b05C5ubm5yWQy3SRjXcOsn2qBQBAWFqbVar/88stqlt6tW7fGjRvfuXNH9z99RUVFQ73cNiEEu0brnEwmmzdvXuX2WbNmBQcHL1u2bM2aNV27dl2yZEmnTp2cnZ1TU1Pv379/8ODBn376ie5CZqCQkJDJkycfPHiwY8eOYWFhLi4uFy9eDA8P79mz5507d3T3Inbp0iUuLm7s2LEjRoywtbX19vYeNWrUq7zGUaNG9evX7+bNm2PGjFm6dKmbm9ulS5e+/PJLPz+/6jvLNGvWbOTIkcOGDWvatKm1tfXjx4/prxxzRYw2bdqIRKI//vjjk08+ad68uVAoDA0N1T3f30B2dnZXrlyZOXPmjBkzLC0tjx49umHDBgcHB/okCtrbb799+vTpmTNn0hemef78+bp16xwcHPS2eOirnn799dfp6el0bIeFhVW+4IiVldWGDRumTJkyYcKEb775pnfv3llZWevWrXv+/Hn//v3Hjh1b05dw586dBQsW9OvXz/COsgxra+uvv/56+vTp9Ck9jD59+lhYWOzcudPPz2/IkCEymezAgQP79u2jdwbqjtmlS5ebN29OmjSpT58+NjY2LVu2pHv/v/322xs2bBg9evSqVau8vb3v3bu3Zs2agIAA3WisRmho6PPnz8eOHbt69Wo/P7+YmJhly5a5ubmVlZXV9DUyM/T396d7XAcEBPTv31936Lhx46ysrCZMmNCyZUtXV9fk5ORvvvmG6HzeWLm5uf35558jR47csWPHhQsXwsLC2rdvb2dnl5+fn5CQcOjQIUKIo6MjM/6333579erV7du3p6amhoWFtWzZsry8PCkp6cyZMykpKTXd3t2+fXtkZOSyZcvi4+PHjx/fvHnzoqKixMTEP/74Q6PRXLhw4aUrhF7Dq1at8vf3r2oN05/qb7/9trCw0MfHh8fjTZo0ydHRcfXq1RcvXvzpp58yMzOnTp3asmVLiUSSlJR07ty5J0+e0H2+BALB+vXr33vvvfHjx2/cuLF79+6pqakrVqzQOxLRwNTjqRuvGb0fHT3MhSF27NhR+RB3x44d4+Li6BGYK8vozX/ChAmEkOjoaKZFpVItW7aM6R3TpUuXyMhI+tjAw4cPmdGys7MHDx7MXAZC78oyetfRv337NiHkgw8+qP7F5ufn654nwOfz16xZ89Iry1TuV2ZnZ7d161bdOZ84cUK3M4LelWUqV1LVlWWuXbume10oHx+f27dv606o1WrnzJmj+4/h7bffpnfS6p5HqNVqv/jiC90fvmquLLNr1y69w4Hjx4/XvWwQc2UZvVdBbzhu376daanFCfW61Go106NY9zzCffv26e4XdXJyOnXqFP1WZmZmMqPFx8f36NGD6dBLX1mGoqiKigrdv2t8Pn/FihVVnUdY+YTR4uLiXr166a6fESNG0BuUuqd41ujuE8ymGHP6IGP69Ol6fdAEAsHMmTOrOZOVkZ6ePnny5Mp9ajw9Pb/88kvd95SiqOzs7NGjR+sdw7azs5s3bx4zDv1PQu+GD6ynZiYmJtIngOpydnbWfYH0GpbL5XplFxcX9+7dm3UNM28ibc2aNS4uLsxozJVl8vLydHec0EQi0UcffaQ7+ebNm3WTr2vXrnRIN9DzCHkU7lBfRzQaDX2eDSsfHx+6ZzYhRC6X37lzhx7Zy8urbdu2umfgSaVSsVjs6Oiod32/3NxciUTi6+ur1/9bpVKJxWJ7e3s6EYODg+Pj4wsKCnQ/5XR5ubm5crnc2tqa2TGiUqn0Lsgkl8uzs7Pt7Oxe2geMoqi7d+/Gxsba2Nj079+/cePGBQUFZWVl3t7ezAZTamqqRqNhurMTQnJych4+fCgWi/l8vp+fX9euXVkP6shkMjpvPDw87OzsZDJZTk6Ovb195b5qYrG4vLzcz8+PWS0pKSl8Pt/f318ikVy5ckUsFnt7ew8aNKhyX01CSFxcXGRkJCGkS5cu7dq1q2rlE0KKiorobnX+/v4CgaCkpCQ/P9/Dw0M3IwkhZWVlf//9d1ZWlq2tbY8ePfQ2ZzUaTVpampWVld5tK0pLSwsLC93c3JgcLSsry83NFYlE1d/gQqFQZGVlVZ4hIaSwsJA+cOXj46N7Vb/c3Ny7d++KxWJfX9/Q0FBbW9vs7Gy5XO7n56d3wW76o6VSqXTXPEVRd+7cefLkiUgk6t+/v5+fX0lJSVFRkbu7O/NW0h+tgICAyv2bKIq6d+9efHw8fb55u3bt6I+c7iIKCgqKi4t1vzLVoN8yQoiXl1flt7isrCwqKio7O1uhUPj6+nbs2JH1rJKqVFRURERE0OvHycmpdevWbdq0Yb3wHiEkPT397t27RUVFDg4Ofn5+Xbp00V3trCtZrVanp6fb2NhUvmhqYmJiVFRUaWmpi4tL48aNu3TpopvK1a/hqKiouLi4atYwg37vCCGNGzfWnX9WVlZERERhYaG9vT39WirvBcnOzr5+/bpUKm3VqlXv3r3VanVmZqatrW3dnoRjGgjC18rt27f79u3bqVOnWndAAADgGhwjbMA2bdqUn58/YsQIPz+/goKC8PDwlStXEkKWLVtW36UBADQYCMIGrKKi4j//+c9//vMfpsXBwWHnzp216F4BAMBZ2DXasCUnJ0dHR9N3b2jSpEm/fv1Mee42AMBrAEEIAACchhPqAQCA0xCEAADAaQhCAADgNAQhAABwGoIQAAA4DUEIAACc1lBPqJfJZNu3b//ss8/qu5Da0Gq1zOWM651ZFUOfzGP4DXiNjaIo8ynG8HeqpKhQI5e9fLzKBEIXD09DXjI+NtUwq5VjVsWY1RdKV0M9jzAjI6N3797V3/THbJWXl7NeabpemFUxcrlcIBBUvuR/vaAoSiqVGnLdZ9Mw/J36bt2qFhZKWxvrl4/6bzeScpau36x7qehXL8YElEolIcR8bgNkVivHrIqRSCQ2NjbmE8yMhrpFCADVaOXv6+pQ45+/W6n6d58H4AKzS2YAAABTQhACAACnIQgBAIDTEIQAAMBpCEIAAOA0BCEAAHAaghAAADjNuEGYm5srk9XqChcAAAAmYawT6sVi8ZgxYzIyMiQSyaJFi77++mu9EaKior766qvHjx+7u7s/evSIae/Ro0dCQgL9uHfv3mfOnKnDqnbt2vXTTz/V4Qxrx6wuevTqxVhaWp47d87JyamuSgIAMCVjBeHy5csDAwPv3r2bmZnZsWPH4cOHd+3aVXcEGxubKVOmlJSUrF+/Xre9rKzszJkzvXv3NkZVT548eeONNyZMmGCMmXPWqFGjSkpKEIQA0EAZJQjVavWvv/5669YtQkijRo3Gjx//yy+/6AVhcHBwcHDwhQsXWOdgvGuzNm7cuHPnzsaYM2dZWVnVdwkAALVnlB10ubm5Uqk0MDCQftqyZcuUlBTDJx86dKhIJOrSpcvt27erGU2j0STrqKioeKWiAQCAk4yyRVhWVsbj8WxsbOintra2paWlBk57+PDh4OBgiqK2bds2atSo58+fe3h4VB5NJpPl5+cPHDiQfsrj8ebOnTtz5szqZ65SqQx+EWAo+i4NdfJHxNzuPiGTyczn9iwSicTA3SRKpVKlVNH3ZKgRlUpdUVGhVqvrsBgTMLe7T5jVyjGrYqRSqUajMXEPCWtra6HwJUlnlCD08PCgKKqkpMTFxYUQUlxczBpmrDp27Eg/+PTTT3ft2hURETFmzJjKo9nY2Hh5edVoQ5MQYia/sK8ZHo8nEons7OxefVZCodCsgpDP55vPbZgoijJwJVtaWlpYWtQiGCwshHZ2dobchsnwYkzA3ILQrFaOWRVDbyCZT1dBhlEKcnFx8fX1jYqKop9GRUW1a9eupjPRaDRSqdSQ7yQAAECtGWWLkMfjzZkzZ9myZT4+PrGxsVeuXPnuu+8IIampqRMnTrx+/bqdnV1JScnly5djYltXRHEAACAASURBVGKkUunx48ddXFwGDhyYnJx89uzZHj16UBS1fft2Gxubvn37GqNCAAAAmrFOn/jss8+USuWUKVNcXFxOnTrVqFEjQoiFhYWfnx+9XVxcXHz8+HFCSEhIyPHjx5s3bz5w4EBra+t79+4dOnSIz+d37tz5xo0bxt4xNXzU6PN/nTbqIhjXrl0LDQ01zbKqp1QqzWc/EgBA/TJWEAqFwpUrV65cuVK30dfX9/fff6cfBwQEHDt2TG8qHx+fQ4cOGakkViVl5ZN3XWnSJcTYCzr52biysjLdltu3b2/btm3mzJlMl5/JkyevXLkyICCAdQ5isTguLo4Z+VXY29unp6d7enq++qwAABo6sztoyR3p6el//vnnwoULNRoN3XLy5MmSkpKqxn/48OGyZctMVR0AAFcgCOtTx44dLS0tDx8+rNeempq6bt26KVOmfPrpp3FxcYQQmUy2f//+jIyMzz//nI7DvXv3Pn78mB4/Ojr64MGDhJCCgoI1a9Y8efJk3rx5O3fulEqlu3fvnjlz5uzZs0+ePGnaFwcA0DAgCOsTn89fu3btihUrFAqFbvvDhw8dHR3feeedJk2ahISEpKWlCQSCFi1a2Nradu7cuVOnToSQo0ePPnv2jB4/NjaW3udcVFT07bffLl68uE+fPq1bt87Ly8vIyBg1atSAAQOWLVt24MABk79EAABzZ6xjhGCgYcOGNW3adPfu3fPnz2cax44dSwgpLS1t0aJFeHj4yZMnFyxY0KdPn6tXr06cOLH6Gcpksh9//NHf359+unbtWrlcnpubu3Dhwl9//XXKlClGeykAAA0SgrD+rV+/fuTIkVOnTmVabty4MWPGDEdHRycnp8TERCbVDOHo6MiMn5+fP2nSpMzMTH9//5KSErlcXselAwA0fNg1Wv+6devWo0ePrVu3Mi0LFizYvHlzVFTU5cuXBw0aRF/lS+86SRYWFswV48rLy3XbmcdbtmwJDAxMSEi4fPny8uXLzedqYQAA5gNBaBbWrVu3ZcsW5kihRCKhz/NLT0//448/6EZXV1exWMyEX/PmzW/evEkIkUqllbvb6M1HoVD88MMPxn4VAAANEYLQLLRt23bkyJFMEK5cufKdd97p3r372LFjBw0aRDd27ty5R48eTZo0oc//W7hw4eXLl4OCgrp27dq+fXvW2c6ZM+fkyZOdO3du375969atmXYLCwvzuQ4vAED94voxQj6PF/7Tmsd/7jL2gtLj7vN403Vb3n333XfffZd5+vPPP//888/04/fff3/cuHGFhYWNGjViEovP5//222/M+AEBAYmJiVlZWV5eXszu0JYtW+bn5zPjBAYGJiUlZWdne3p66t41ELesAgBgcD0It2/5b2JiokkW9daAAQMMH1skEolEourH4fP5jRs3rn4coVDo5+dn+HIBALiG60HYunXrJk2amGZZ5nMzFAAAYHA9CMeNGX3r1i2BQGDsBUmksrPnzr3xxhvGXpBRqVQquVxub29f34UAANQZrgehtKLiyFcL+rYLMvaC3vt2h1Qqrdx+9+7dbdu2xcbGikSiVq1aTZs2rV+/fsYuhvHgwQOFQtGrVy8Dx7969erKlSvv3r1r1KoAAEwJvUbr07FjxwYPHtyxY8eDBw/u2rWrV69eH374oSkLOHPmzNGjR025RAAAc8P1LcJ6JJfL582bt2nTpo8++ohu6dChQ1hYGDPCqVOn/vrrL0LIu+++S9/I8O+//y4oKJBKpWfPnm3SpMkXX3zh6OhICNFoND/99FN4eLiTk9OcOXNatWpFCDly5Iivr++dO3eio6O///77hISEEydOZGdnN2nSZMGCBb6+vgkJCVeuXJHL5Z9//nmTJk1mzZpFUdShQ4euX79uY2MzY8aMDh060JX89ttvf/31l4+PD32ZUwCA1wm2COtNVFRUQUGBbvIRQmxsbOgHmzZtWrdu3dixY0eMGDF9+vQrV64QQu7evTtnzpz4+Pjp06c/ffp03rx59MhhYWGXL1+eOnVqu3btQkNDMzIyCCGnT59+//33BQLBlClTrKysYmNje/fuPX/+fHt7+/79+ysUCldX16ZNmzZu3HjQoEFdunQhhMyfP//IkSPvv/9+r169hg8fHh8fTwjZu3fvihUr3n333Xbt2uE+UADw+sEWYb0Ri8Vubm7W1tb002XLlhUUFNAPfH19V65cGRMT06xZM0JIRUXFDz/8QJ9ZHxgY+O233xJCvLy8hg4dSgiJj4+/cuVKZmampaVlaGhofHz8gQMHvvrqK0LIyJEjlyxZQs9/1qxZSqVSLBa/9957R48ejY6O7tmzZ9OmTYuLi+k55+Tk7N+/XywW071b09LS9uzZs3Xr1i1btmzevHn48OGEkOTk5HPnzpl8VQEAGBGCsN44ODiUlJRoNBq6z2pwcHB5efnHH388c+ZMjUYjlUonTZpEjymXy11cXOjHLVq0oB+4uroWFxcTQuLj42UyGdPhpbS0lA5IQoju1WS+++67zZs3BwYGOjk55efn5+Tk6NXz7NkzjUYTEhJCPy0vL6c3E5OSktq2bUs3tmvXDkEIAK8ZBGG96dq1K5/Pv3btGn1OxTvvvEMIWbRoESGEjr1r1645ODjoTcXn6+/NdnV19fHxuX//fuVFCIX/vL9lZWVLly7NyMhwd3cnhAQHBzMX8mauxO3q6mpnZxcVFaV39TUnJ6fi4mL6jhZFRUWv+KoBAMwNjhHWGxcXl08++WT27NnM2QjZ2dkajYYQ4ujoOHjw4BUrVtBPZTIZfbiOVffu3RUKxf79++mnBQUFqampeuOoVCqKougLdp85c4aZm7u7e2pqKp2FrVu39vLy2rx5Mz2otLSUvubOiBEjtm/fTlEUfafDOnv9AADmAUFYn9atWzdr1qwJEyY4OTk1atSoX79+X3/9dVBQECFk//79GRkZjRs3Dg4ObtGiBX2jCWtra+a6a3w+38nJiRAiEolOnz79448/BgQEBAYGdu/ePSUlhRBia2vLXF/U1dV16dKlwcHBbdq02b9//+DBg+m7UkyaNEkulwcEBLz99ttCofCPP/44e/asn59fUFBQ+/bt4+LiCCHffPNNUlJSkyZNOnTo0Lt3b5xNDwCvGV4DvUddRkZG796909PTazTV3Llz27RpM2fOHKZlQP9+qrJid2enui5Q393YZ7v37hs1ahTr0KKiIpFIxHScYajV6vLycmdnZ0MWIZfLVSpVNUEll8uVSmXl3a16lEqlXC7XG628vNza2lr3ZoeMgICA69ev18mV6uRyuUAgYF2K6VEUJZVKbW1t67uQf5SXlxv4L+S7datGNXd3dajxX5btVyI/Xfffyp/DVynGBJRKJSGE/m9nDsxq5ZhVMRKJxMbGpvLxnXrH9WOE332/49mzZyZYUJhQOHDgwKqGMn1h9AiFQgNTkBBibW1d/U/YS0egWVpaVv5NMZ/vEgBA3eJ6ELZt25bpEgkAABxkdpuoAAAApoQgBAAATkMQAgAApyEIAQCA0xCEAADAadzqNWpjY7NkyZLly5fXdyGvFfoUw/quAgCglrgVhN9++6053EiooqKCvsODOXj1YgQCwUtP0gcAMFvcCkILCwvDz083HqFQaD7np5tVMQAApodjhAAAwGkIQgAA4DQEIQAAcBqCEAAAOA1BCAAAnIYgBAAATkMQAgAAp3HrPEIAADNBUdSZcxclClUtpvV2dwnp27vOS+IsBCEAQD1QqVR//h1l2W5ojSeUS92eRSEI6xCCEACgfvD4fO+gTjWdSl5WrM17aIx6OAvHCAEAgNMQhAAAwGkIQgAA4DQcIwR43RQVF+fmapWSihpPWFRkjHoAzByCEOB18+R5khvV1MFeU9MJ45LS5XI5brMMXIMgBHjdUITYeTZ2cvOo8ZS8m0YoB8Dc4RghAABwGoIQAAA4DUEIAACchiAEAABOQxACAACnIQgBAIDTEIQAAMBpCEIAAOA0BCEAAHAaghAAADgNQQgAAJyGIAQAAE5DEAIAAKchCAEAgNMQhAAAwGkIQgAA4DQEIQAAcBqCEAAAOA1BCAAAnIYgBAAAThPWdwEADZ5KpTpx6oxCqanFtM38G/Xt3bPOSwIAwyEIAV6VVCq9+OCFbafhNZ1QVlqU9eAJghCgfiEIAeqAQGjh3rR1Tacqz8siL54box4AMByOEQIAAKchCAEAgNMQhAAAwGkIQgAA4DQEIQAAcBqCEAAAOA1BCAAAnIbzCAHMhUQiyc3NrWaora1tVUO9vb1tbGyMUxfAaw5BCGAuoqOj7/x+2MmePe1UKpWFhQXroOIK6YB3p3Xt2tWY1QG8thCEAOaCoqggb5d+7YJYhyqVSktLS9ZBlx/GUxRlzNIAXmc4RggAAJyGLUIAc6HRaBQKhVwuZx2qVCq1Wm1NB9U7pVIpkUhqN62TkxOPx6vbegAqQxACmIv4+PjUJwnSCvYg1Gi1Aj77Lpz7iSnqpgk9evQwZnW1dPHKtaM3H1lYWtV4SoXk82kTAgMDjVAUwL8gCIHT1Gq1SqViHURRlEwm41eRPXw+38qq5j/u1dJqtQJ7N8dW3VmHajQagUDAXoy4VKOpzd0QTUCl1ti07u/bpsYdeTL/Pm62L6quaDUatUJW06nUCjl53deMiSEIgdN+PPTr3WcZPB5L2lGE0qg1QiH7d8SGKL79fIGTk5ORC4TXllqtTrp7VZIrrvGEKoWqopCQxcaoipsQhMBpFQq1c59JTj5NWIdWc8ZC5pkf1Gq1ESuD151Wq7Xhad8PqfEO7dLiwhNXLhujJM5Cr1EAAOA0BCEAAHAado0Cpz19cC/3+m1LW3vWoVqttqrOMiUZCRVTRrm5uRmzOgAwBQQhcJpaWvFGC3/fRk1Yh2q1Gj6fvaPmkcx4pVJpxMoAwFQQhMB1QoGwqkuXaTUafhVnLOBEb4DXBo4RAgAApxlri1ClUu3atevx48fNmzf/+OOPRSKR3ggFBQX37t17+vRpq1atRowYwbSXlZVt27YtLS2ta9eu06dPr+oMYgAAgDphrCCcPXv2s2fPZs+efeTIkVu3bv311196I6xduzYqKqq8vLxTp066QThixAgPD4+xY8d+9913z54927x5s5EqBAAAIEYKwpycnF9++SUpKcnX13fMmDGenp6xsbHBwcG642zdupUQ8uWXX2ZnZzONERERT58+vXr1qqWlZbdu3Tp27LhixQpcvAMAAIzHKMcI79+/HxAQ4OvrSwixtbXt1q1beHi4IRNGRET07t2b7rnQsmVLZ2fnmJgYY1QIAABAM8oWoVgs1j2/ysPDIycnpxYTuru7VzWhXC4vLCwcP3480zJmzBjdp+ZMJpOZz7FPsypGLpcLBIKqrmpmDBqNRqvVaqu4hLGm6nsbUVqtTCaTSqWEEJlMVs3Fu6uhUquVKhU9E0LfTYmqshitRlNVR1VKq1Uqlcx8tLSaX5eZvs54VX1odRn+sVEoFLVbOWq1Wi6XMy+qGvR5LOZzxTsDV45UKtVqqVq8TVqtlqK0hqwZw4sxDalUSlFUVefmGomlpWVVVwxmGCUIraysdD/3CoXC2tq6bie0srISiUSTJk1iWtq3b2/gUuqdSqUyn1LNqhhCiImDkC/g01iHUoRUNYjH51lZWdGrTqFQCISCl37ZKhMKBUKhkFn/FhYWPMKrspiqf0F4PL6FhQUzHz6Pz+dVOZ9q8Hj//6KqZ/jHxtLSUiCozcoRCAWWlpaGLIV+pYbkt2kYuHLUajWPX5u3ic/j83h8A9e/WX3BNRqNtbW1iYPQkMUZJQh9fX0zMjKYpxkZGQZuq/n6+kZERNCPNRpNdnY2vX+1Mh6PZ2Nj89Zbb716taZXzS+v6ZlhMaash0d4hBBSxUmBvKoHEcJjSuXz+TzCq8WZhTzC000sHo/H4/GqXGJ1gwhPN/l41Y5cLQPXv+FvE+9/aloJT2cNv7QYYtjvnWkYXna1H7Cq8f6ZvA6LMQ3Tf8ENZJSC+vTpo1Kpbty4QQh59uzZ06dPhw0bRghJSUm5fv16NROOGjUqMjIyLS2NEHLu3DlHR8fOnTsbo0IAAABadVuEubm5OTk5evfGNCSZrKysNm7cOHHixJCQkPDw8FWrVrm6uhJCLly4sHv3brr/y6+//rpp06asrCyVStWlS5cPPvhg/vz5jRs3/vTTT3v37t2zZ88bN27s2rXLfPZuA0At5OXlZr1IVkjKajphQcKTij5NjVESgB72IIyNjZ05cyazl1IXRVGGzHfy5MkhISGxsbHffPNNixYt6MZ33nmH3jQkhAwfPrx79/+/EzdzjsTq1avfeeed5OTkrVu3VrVfFAAaiqy0lKbpiY34uTWd8HHmo9zcGt+rD6AW2IPwnXfeKSgo2LZtW8uWLWu9Tebv7+/v76/b4uTkxASeo6Ojo6Mj64RBQUFBQUG1WygAmBt3F5egFi1rOlVy0nNjFANQGUsQlpaWxsXF/fnnn6NHjzZ9QQAAAKbEEoR0/y4fHx+TFwPQIGm12qLcbOHT6JpOKCnO4xcXGaMkADAcSxA6ODiMGDHizJkzXbt2NX1BAA1ORUWFJOGBs32NT38UlhanlxUboyQAMBz7McKFCxdOmzatqKho2LBhXl5euoNwPgNAZdZCfs82NT6wLc5Ov/EYW4QA9Yw9CN97773c3NwdO3bs2LFDb5CBvUYBAAAaBPYgPHbsGH35PgAAgNcbexD269fPxHUAAADUi+quLFNUVBQXF5eZment7R0UFOTp6WmysgAAAEyDPQg1Gs2SJUt27NjB7CAVCARhYWE//PCDjY2NCcsDAAAwLvYgXLFixdatW99///2JEyf6+Pjk5+efOXPmxx9/JITs37/ftBUCAJgXpVIpkUiqGlpRUVHVzREFAoGDg4PR6oJaYglCtVq9Y8eOL7/8cu3atUzj0KFD27RpM3/+/E2bNrm4uJiwQgAA83L6jxMv7t+xqOImiyqVqqp7akrU2o8+WYrLlZgbljcyLy+vtLS08q3+Jk2aNHfu3OTkZAQhAHCZWqEY0MK3lR/7XQGUSmVVdwk+EvG4qo1FqEcs9yO0t7fn8/mpqal67XRLVVfKBgAAaIjYg7B///4ff/zxvXv3mMb4+Pjp06e3atWqefPmJiwPAADAuNj3ce/cuTM0NLR79+7+/v50Z5mkpCRHR8fz58/Tl+QGAAB4PbBsERJCAgMDY2Nj169f37ZtW7Va3aJFi6+//jo+Pr5HD9wnEwAAXitVnlDv4uKydOnSpUuXmrIaAAAAE2PfIgQAAOCI/98iPHv27Nq1a2fPnv3BBx+MGDGiqIj97jB37twxVW0AAABG9/9BaGNj4+npaWtrSwhxd3ev6oRQAACA18n/B+GAAQMGDBhAPz5w4ED9lAMAAGBa7McIDx06lJubq9eYm5u7Z88e45cEAABgOuy9RpcsWdKsWTO9+y4lJyfPnDlzxowZJikMAOD//X76bGEZ+3Wu1WoNIUQoFLAOdbW3HT96hBErg4avuvsR6pFIJPQRRAAAE7sS+YgED+OzXedaI9QQQgQCliDUajSau38hCKF6//pUPXnyhO4UKpPJTp06FRsbywxSq9VHjhwJDAw0dYEAAIQQQtyaBAosrSq3azRVB6FaJX70l9ErgwbuX0F45cqVTz75hH68YcMGvVGbNGmyd+9eE9UFAABgEv8KwmnTpo0ePZoQ0r179507d3bq1IkZ5OHhYWdnZ+rqAAAAjOxfQejo6Ojo6KhQKGbPnt2sWbOmTZvWV1kAAACmwXL6RGFh4Zo1axQKhemrAQAAMDGWIPTw8HBychKLxaavBgAAwMRYglAoFH7xxRerVq3Ky8szfUEAAACmxH4e4YsXL9LT05s2bdq9e3dXV1fdQceOHTNJYQAAAKbAHoRpaWkBAQGEkNLS0tLSUtOWBAAAYDrsQXjp0iUT1wEAAFAvcGNeAADgtCqvNVpYWLh3796YmJjMzEwvL6/g4OAPP/zQx8fHlMUBAAAYG/sW4fPnz9u1a7d06dLbt28rFIr79++vXLmyTZs2kZGRJq4PAADAqNiDcNasWXw+Pzw8PD09PTIyMjk5+dGjR40aNZoyZQpFUSYuEQAAwHhYgrC8vPzmzZvff/99r169mMa2bdvu37//2bNniYmJJiwPAADAuNiDUKvV0qdP6KIvPYqzKQAA4HXC0lnGw8PDwcHh+PHj7dq1020/fvy4QCDAlbgBgOO0Wq1Go1Gr1axDVSoVn89+1Im+dSKYG5YgFAqFc+fOXbduXUZGxltvveXt7Z2fn//XX3/t2bMnLCzMxcXF9FUCAJiP+zGP0ktzklPSWYdqNFqBgD0I7z5J7Jmf7+fnZ8zqoMbYT59Ys2aNTCb74YcfDh48SLcIBIKwsLAdO3aYsDYAAHOkUKmFHgH2rYJZh2o0GoFAwDqIep6jUqmMWRrUBnsQCgSCLVu2LFu2LDIysqioyNHRsWvXrt7e3iYuDgAAwNiqPKGeEOLm5jZixAiTlQIAAGB6VQahWCzevXt3TExMVlYWfWWZGTNmNGnSxIS1AQAAGB37Ed179+61adNm9erVycnJTk5OWVlZ//3vf9u0aXPhwgUT1wcAAGBU7FuEU6dO9fLyioiICAwMpFsyMjLee++9yZMnZ2RkWFpamrBCAIC6kZWVdfznfdoqTnuoBo/H6zlgcA+da4zA64QlCHNzc+Pj469du8akICGkcePGP/30U2BgYFxcXMeOHU1YIQBA3SgvL7eVlQxu26KmE8anZuaLc4xREpgDliAUiUR8Pt/d3V2v3c3NjRBia2triroAAIzAQiBwsqvxj5iNlWW5MaoB88ByjNDe3n7EiBE7d+7Ua9+1a1enTp1atmxpksIAAABMgf0Y4fjx4z/55JNHjx6NGzfOy8srPz///Pnzt2/fXrNmzfHjx+lxunTpUvl6pAAAAA0LexAuXbq0qKgoPDw8PDxct/2TTz5hHv/4448ffvihcasDAAAwMvYgjIyMfOnFYSsfRAQAAGhw2IPQ39/fxHUAAADUi+ousZaQkBATE5OZment7R0cHNy2bVuTlQUAAGAa7EEol8unTp3622+/6TYOGTLk119/dXZ2NklhAAAApsB+ibXFixefOHFiyZIlDx48yMrKevTo0Zo1a27fvj1t2jQT1wcAAGBULFuESqXywIED33zzzZIlS+gWHx+fdu3aBQQEhIWF5eXleXh4mLZIAAAAY2HZIiwoKJBKpcOGDdNrHz58OEVRaWlpJikMAADAFFiC0MnJSSgUxsbG6rXTLThrAgAAXicsQSgSiYYOHfrxxx+fOnVKq9XSjdevX58yZUqnTp1wS0IAAHidsHeW2blzp5ub25gxY2xtbQMCAmxtbQcMGKBUKg8dOmTi+gAAAIyK/fSJRo0aPXz48NixYzdv3iwrKxOJRD179nz33Xft7e1NXB8AAIBRsQRhcXHxW2+9tXLlyg8++OCDDz4wfU0AAAAmw7JrVKvVXrlyRSAQmL4aAAAAE2MJQldX17Zt2965c8f01QAAAJgY+zHCffv2TZo0ycrK6s033/Tx8eHz2fvUAACYhkqplJeXCCwsKw/SaDWEEAGfZSeWVqNWKZXMU4qilEqlXC6v6dKVSqVKra7pVNBQsAfhyJEjc3Nz586dO3fuXL1BFEUZvyoAgH9JuX9Lmp/LE7D8ZNE/Sjwej2WQVpuT8pR5mpaWFvko3lqlqunSk7LF2mJq3FuTajohNAjsQbh8+XKJRGLiUgAAqiKgNGO7d7S0sq48iNJqCSE8th1XapVyZ9IT5qlWq+XZODi26l7TpQtl92RabAO8ttiDcN68eSauAwAAoF7oB+GjR4927dqVkJDg4eExbNgwnD4BAACvt38F4ePHj3v16iWVSu3s7CQSyW+//ZaWlvbVV1/VV3EAAADG9q+96lu2bLGwsIiIiCgvL8/LyxswYMDGjRvV6CsFAACvr38F4dOnT6dMmdKzZ09CiJub27p168rLyzMyMuqpNgAAAKP7VxDm5ub6+fkxT/39/QkhYrHY1EUBAACYyr+CkKIo3XNx6Mc4cRAAAF5j+r1Gd+3ade7cOfqxUqkkhCxcuNDR0ZEZ4fLlyyYrDgAAwNj+FYR+fn5ZWVnJyclMS9OmTQsLCwsLC01eGAAAgCn8Kwhv3rxZX3UAAADUC1xNGwAAOA1BCAAAnIYgBAAATkMQAgAApyEIAQCA0xCEAADAaQhCAADgNAQhAABwGoIQAAA4DUEIAACchiAEAABOQxACAACnGTEIKYpKT08vLi6uZpz8/PzMzEzj1QAAAFA9YwVhZmZmhw4dBgwY0KxZs6VLl1YeQavVTps2rXXr1r179+7Tpw+Tl61bt+b9T2hoqJHKAwAAoBkrCJcvX969e/fExMT4+PiDBw/euXNHb4STJ0/evn07KSkpNTXVzc1tw4YNzKDbt29TFEVR1PXr141UHgAAAM0oQahWq48dOzZnzhxCiJeX17hx444cOaI3zuHDh99//30HBwcejzd79uzDhw/rTi6TyYxRGAAAgB6jBKFYLJbJZC1atKCftmjRIjU1VW+c1NTU5s2bMyNkZWWpVCr66ahRo1xcXFq3bn358uVqlqJSqR7oKC8vr+OXAQAAHCB8+Sg1R2eStbU1/VQkEpWVlemNU1FRYWNjw4yg1WorKiqcnZ1///33Vq1aEUJ27tw5fvz4hIQELy+vyouQyWRFRUUfffQR0xIWFqb71JxJJBIej1ffVfzDrIqRy+UCgcDCwsJkS9Ro1FqNRqPRsA7VajRUFRNqtVqJRFJRUUEIkUqlWi1V1UyqXTql0WjomRBCFAqFRltlMdXMX6vVKhQKZj4ajVZb9XyqQWkpiUQiFL78Z8Hwj41KpeJT2loUo6W0crmceVH/vCS2+VBaLSGER7G8VxqNhtJomZnI5XJtLYuhVCoVT5CCBgAAGvtJREFUMx+VWl1VMaTad0qj1UqlUno+FRUV9IuqaTEajZb+wTRkZLP6gkulUo1Gw+eb9GwFa2vrl36kjRKEnp6ehJCSkhJXV1dCSFFREd2iy8PDo6SkhH5cVFRkZWXl5ORECAkKCqIb58yZs3Xr1oiIiHHjxlVehI2NjaenZ3R0tDHqNzaKouzs7Oq7in+YVTFCodDEQSgQCPkCgUAgYB3KI4RfxSA+n29ra0uvOpFIxOfzqppJtUvnCQQCZv1bWVkJ+FUWQwipahCfz7eysmLmIxDw+dXOpyo8Po95UdUz/GNjYWHB5/FrUQyfx7e2tmaW8s9LYpsPxeMRQnhsP6+UVsAT8JmZWFtb17YYnoWFBTMfC6GwqmJoVQ0S8PkikUjvRdW0GIGAz+fzDVz/ZvUF5/F4NjY2Jg5CQxilIGdnZz8/v8jISPppZGRkhw4d9Mbp0KGD3gh6f1tUKlVZWZn5vIUAAPBaMsoWIY/Hmzdv3ueff+7i4vLkyZMbN27s3LmTEJKcnDxy5MjIyEh7e/tZs2b16tUrNDTUx8dn9erVa9asIYQkJiaeOHGiV69eWq12x44dTk5Offr0MUaFAAAANKMEISFk8eLFFEUtWbLE1dX1/Pnz3t7ehBBra+vOnTvTuwLatGlz7Nix7777TiqVLl269P333yeE2NnZpaSknDt3TigUdu7c+fvvvxeJREaqEAAAgBgvCPl8/mefffbZZ5/pNvr4+Bw6dIh5OmTIkCFDhuiO4OXltXv3biOVBAAAUJnZHbQEAAAwJQQhAABwGoIQAAA4DUEIAACchiAEAABOQxACAACnGev0CQBo0MrKyv787YhWrWQdqlQoLK2sqpq2ZdsOvfv2M1ppAHUMQQgALMrKygoT4wcG+bMOVQk1FhYq1kFZ+UVpiQkIQmhAEIQAwM7a0rKJlwfrIKVSaWlpyT5IpSkxZlUAdQ7HCAEAgNMQhAAAwGkIQgAA4DQEIQAAcBqCEAAAOA29RqFBKikpiY2Nrd20zZs39/Lyqtt6AKDhQhBCg5ScnPzdxcc2Ps1rOmGZOGOeQoEgBAAGghAaKkcP30bdBtZ0qrToW4RojFEPADRQOEYIAACchiAEAABOQxACAACnIQgBAIDTEIQAAMBpCEIAAOA0BCEAAHAaghAAADgNQQgAAJyGK8sAADuNRqNWq1kHqVQqPp/9b7RGo9YKtMasC6COIQgBgEVBQcGd6EcOSinrUK1WW1UQZhcWi+3c3jdmbQB1C0EIACxUKhVlKXJq05t1qEajEQgErIMKEuIVxSXGLA2gjuEYIQAAcBqCEAAAOA1BCAAAnIYgBAAATkMQAgAApyEIAQCA0xCEAADAaQhCAADgNAQhAABwGoIQAAA4DZdYgwapsLAw88Hf0tIaX8qrMP1FtnWgMUoCgAYKQQgNUn5+vk95akfiXtMJEyoS83KdjFESADRQCEJoqGytbfx8fGs6lTgt0RjFAEDDhWOEAADAaQhCAADgNAQhAABwGoIQAAA4DUEIAACchiAEAABOQxACAACnIQgBAIDTEIQAAMBpCEIAAOA0BCEAAHAaghAAADgNQQgAAJyGIAQAAE5DEAIAAKchCAEAgNMQhAAAwGkIQgAA4DQEIQAAcBqCEAAAOA1BCAAAnIYgBAAATkMQAgAApyEIAQCA04T1XQAAANReWlratXNnCKVlHapUKCytrKqatueAwa1atTJaaQ0GghAAoAHLz8/XZiZ2ad6YdahKqLGwULEOik3OEIvFCEKCIAQAaOjsbW2aeHmwDlIqlZaWlqyDMvMKjVlUQ4JjhAAAwGkIQgAA4DQEIQAAcBqCEAAAOA1BCAAAnIYgBAAATkMQAgAApyEIAQCA0xCEAADAaQhCAADgNAQhAABwGq41+i9arTYtLY2iqFpM6+Tk5OLiUuclAQCAUSEI/yUvL++XHVu87GxqOqFMoXBtGfze1A+NURUAABgPgvBfKIpytBK+1T24phMmZYtj1WpjlAQAAEaFY4QAAMBpCEIAAOA0BCEAAHAaghAAADgNQQgAAJyGIAQAAE5DEAIAAKchCAEAgNNwQj0Y6uzFyxfDH9RiQhsLweKZkz08PAghWq127aZtBeVy1jE1Gg2Px+Pz2f+ftfTzmvfhlFoUAPAaS0tLi3z4WFtSxDpUo9UKqvhCPc3IaeQSEBISQj898duRhMcPa1GApY3d7E8+tbW1rcW0ZgJBaGoajebSpUvjx4+v70L+ce3ataFDh1pZWb10zLyiUkXgIPeAVjVdRM7fR6VSKf2YoqiUvDLfsZ+wjpmdk2NjbePg7FR5kEJSnhL5a00X/SrUKlVFRYWTs7MpF1qNoqIid3f3+q7iH6UlJY5OTgKBoL4LIYQQmUxGEWImP8Rajaa0pMTF1dVkS5RKpUpLR6vm3ViHFhQUuLm5sQ5SFNySSCTM0+Jc8bBmnj5uNf7AHwx/rFQqDVn/kZGRbdu2NZ+PMcNYQSiXy7dt2xYdHd26deuFCxc6ODhUHufUqVO///67nZ3d3Llz27RpQzcWFRVt3rw5KSmpe/fuc+fOtbCwMFKF9UUsFs+fP998gvDzzz9v0aJF69atDRlZYGEptKrxhVh5PP0/pFXNJO7pc2dn5x5e3pUHaVRKZU0X/GpKS0uzc3LMJAi1Wu2zp0/N5xckLT29qVDo6OhY34UQQkhefj5FUQEBAfVdCCGEVEgkqWlppgxCQgiPx+ML2X8qn79IdHX3YP3LUvmLaWVhYW1pWYulGzjmd999N2XKlLFjx9Z0EcZmrGOEM2bMuHDhwqRJk2JiYiZMmFB5hBMnTsyYMWPIkCG+vr59+/bNycmh24cNG5acnPzWW28dP3580aJFRioPzFbtbv0BAA2CeX7BjbJFmJWVdfTo0bS0NC8vr2HDhnl4eMTExHTo0EF3nP/+97/r1q177733CCEPHz788ccfV6xYcfPmzZSUlPDwcKFQ2K5du7Zt265evboh3tvoYcyj8zfvsg4qKyuvINbfbNvNOlTA570/doSvry/9dP7H8/NyxbUowMnJedeefxaRn59/4OifKi37569Qydvz6x8e7rdYhw7s0bl7ty61KAAAOEgmkx3ev1etkLEOLcxMvX7udF5aEuvQZkHBbwwdZszqqmSUIHzw4EHz5s29vLwIIdbW1t26dbt7965uEGo0mvv37x86dIh+2r9//wsXLhBCIiMje/XqJRQKCSHNmjVzdXV99OhRaGioMYo0qsycnKd8P4/mLHexqJBItN1LC1sOZ52w4NGNoqIiJggT4uNG9O5tZWldo6VrKO2JixeYpyUlJXGlAtfOg9lH7ppX0mqkgG1PTmFaQkBGFoIQAAwkk8kKUxLGtG/OOrSsqVvrRg4t3Fl6JOSVlD1PeErqKQh5xthQ3bNnzy+//HLz5k366dtvvx0YGLhq1SpmBLFY7O3tXVhYSG/t/frrrxs3boyOjl68eHFJScnevXvp0Tp27LhkyZJ333238iLi4uLat2+ve4jCy8uLjt5XoVAo+EU5PvY1Cx5CiFqjTZHznDz/ObiVX1iUI3TnCVneb61WU1xU7FrF4WsiLQ2wUdjZ2dHPcjOzmnp786ro9FUlikrMyvJq3Ih+JpFIkiUCYsu+YV1cVOjg4CgQsvwlotRKd1W+9/8OnmcXlBRYuPGENT6EQCoKmjvwbGxsCCEURT3NLtY4NWIfsaJcwOfbiNiOulMa63JxC+9/iiksLHSysHC0Zzn2XD2FXJpRWu7l5Uk/FWeLA9xdBWzHV7QatVKptLYRsc4nMy/X2tHR2tqaEKJUKiVFRY09a/zx06pVyfkFXj7/fGxyc3N97eytRaxLpCQVFbZ29qzzqZBUFMjlTJ8IcVZOUy8PPr/GPVlSc7KdPDzof6ISiYSSyryq+KDKpFIrKys+25EntVKRWlTs5f3P2hCLxX5OTpZWNf5OFZWWSCjK+X/HaMWZmc19fAnb4SiVUkFRxJK1wxdFJWZnezX6559laWmpjZZycWLpjVW9/2vvXoOaONcAAH8QGzEJl0CCAUJJAyhUK4O0inKpiRTrXVHbUYuFiKKi0gpKC0VnOlLETqfW2hGn6ngr1sh4GQWGjuCMilTAWhGrIuKacAkQhEACSSC758f27MlR8FSP7EZ5n1/ZbzfZd5PdfbO738VsMqo6dCKPf+82mhYJ32UEe6AD3GIxmYwD78MItbS3Ew4jyQMcx3Ftc7PU0+t5g8FxS31zi0jsSU5qtVq3kWxH3sDHgkGv5/K4CA3wvZmMPWpdF3Xa1Gka3xplx2I99/MydZeRJfQi63P09fVZ2hq8nQauBNCl0zk4OAz4S1kseH0v4SJ67m/jf4qJiUlKSnr2MkNyRThq1CiTyURNGo1Gzn8f2+Q5kVqGWmDUqFGtra3PeCMlICAgJSXFzeo6RiwWkxX0bRxBEBiG2ciDfYQQhmE+Pj7//HH3kNJqtSNHjnR0HPh0TzOTydTe3u7p6cl0IH97+PCh7ew2arXaw8NjxED/n+jX2dlJWKVMZvX39zc3N3t7ezMdyN9sardpampyc3P7J3XUX6J/svlDsh+LxWK1Wk0QBHl6ValUS5YssV7A2dnZ0dFRpVJ5eHiQC4jFYvKNly///bCqv7+/qamJLH8ai8XKyckZiuABAAAMK0NSazQsLAzH8d9++w0hVF1dXVtbO2vWLITQ/fv3i4qKyGUWLVp05MgRhJDRaFQqlWRzgnnz5lVWVtbV1SGEzpw5IxAIJk6cOBQRAgAAAKQhuSJks9m7du1avnz5pEmTKisrd+zYQd61uHDhwr59+2bOnIkQ2rp1q0wmu337tkaj8ff3J1uWeHp6ZmZmhoWFTZw4saqq6uDBg4N1MgIAAAC8FENSWYbU2tp6+/btMWPGUHUgDQaDXq8fPfrvB84mk6mqqorH4wUFBVm/UaVSPXjwYMKECW70NkoFAAAwDA1hIgQAAABsn01U+ho+LBbL3bt3m5ubp02bxniNOwzD/vzzz46ODj8/v/DwcGYrjl69epXqjxQhJBAInuiBgQY4jt+7d6+xsTEyMpJt1dFUV1dXdXU1n8+nOgKkx6NHj+rq6oKCgqh2Ed3d3RUVFQ0NDc7OzjKZjM4eznQ6XXV1tUAgCAwMJEuMRuOVK1eoBfz8/CQSCT3BmEymW7dumc3mqVOnkiUGg6G8vNx6mcDAQOpe1JCyWCx37tzRaDQymcy6J7N79+5VVFR4eHjI5XLaHvEYjcaysrLGxkaJRBIREWF9UNfV1WEYNnnyZNpqZeM4XlFRUVtbKxQK5XI5VVm0rq6uurq6q6srICAgNDSUnmD+BwLQ5e7duzwejzyp6XQ6psMhJkyYsHjxYoVC4e/vHx0d3dfXx2AwcXFxUf/G5/NXrVpFcwAYhjk6OpK/TnNzM1W+ZcsWNpvt4uKyYsUKOuORSCTOzs5sNrugoIAqzMzMlMvlK1eujI6OdnV1vXHjBj3BJCcns9lsZ2fn1atXU4UqlYrFYlG/2vHjx+kJJj8/n81mCwQCPz8/qhDDMCoScjiFoqIiGoKpqanhcrnkbmMwGKjy3bt3e3p6rl+/PjQ0dM6cOTiO0xAMQRAikSg8PDwuLm7s2LFyudxkMhEE0dvb6+Li4urqam9vf/36dXoiIQhi5syZ77zzzqeffhoaGiqVSqnDytfX96OPPoqPj5dIJIsWLbJYLLSFNBhIhPQxGAyNjY2NjY02kggp3d3dTk5OZWVlTAdCEASh1+sZCaa3t1etVnd0dDyRCBsaGnp6etLT02lOhA8ePMBxXCqVWidCa/Hx8QkJCfQEo1are3t7N23a9EQi5HK59ARgTavVdnR0nDt3zjoRWjtz5oxIJKLnj53BYGhqanr06JF1Iuzu7nZwcKisrCQIoq+vz9/fv7i4mIZgCIKoq6sjX+j1epFIdPr0aYIgLBZLfX09QRAcDofOREgFQxCETCbLzMx8YgGtVvvGG2/U1NTQFtJgoE4mfTgcju20zrZmNBpxHLeRPl1PnjwpEommTJlC83odHBwGbLTq5eVF9v9AM6lU+uyb1T09PYMNr/PSicVisg+dJ+A4fvHixcuXL+v1enoiQQi5ubm5PLNrmAMHDigUCnoePXA4HLIxtDUMw8xmM9n0a8SIESEhIWfPnqUhGISQr68v+YLL5To7O5vNZoSQvb09I23qqWAQQiKRyPzU+DG9vb0sFssWxjCBRDisbdu2bfr06RMmTNi9e3dAwHMPNDgUDhw4kJCQYCM93digq1evfvDBB+PGjTOZTBkZGcwGIxQKv//++88//1wqlV68eJHZYEgtLS3FxcVxcXEMxiAWi+3s7P766y+EEEEQNTU15H0gOimVSoPB8OGHH9K83gHdunWrsLAwNjaWKklNTZXL5aGhoYcPHx6s1xQ6QWWZYS0mJmby5MklJSVff/31rFmzqJYtTKmtrb127ZpSqWQ2DFvm7++flpZWX1+/ffv2s2fPkuO3MMLLywvDMPIvy7fffqtQKB4+fMhUMJRDhw5NmTLF39+fwRhcXFzS0tLmz58fGxtbUVFhNpsJeivnl5eXr1+/Pj8/f8CBYGnW0NCwYMGCHTt2WNc1W7p0qUwmO3/+/NatW2fMmMH4RSFcEQ5rQUFBs2bN+u677yQSyfHjtI7/PqCDBw/Onj376XtNgCIUCqOiolavXr19+/adO3cyGIm9vT114b5s2TIMwzo7OxmMh3To0CGFQsF0FCgrK+vIkSNCoTAjI0Mul0ulUtpWff369QULFhw+fDgyMpK2lQ5Go9FERUWtXbt2zZo11uUhISGzZ8/eu3cvh8M5deoUU+FR4IoQIBzHHz9+zPifx/7+/qNHj+bm5jIbxqtCq9Uy/pNRrl+/7uTkxPj/+itXrjQ1NQ04Ejj9wsLCwsLCdDpdfn7+iRMn6FnpzZs358yZ8/PPP5MdeDGrra0tKioqNjY2NTV1wAX6+vp0Oh3juw2CREgnHMfXrl1LtpZLTk7mcrl79uxhKpiamprU1NSpU6ey2ezi4uK+vj7GTx+FhYU4jjP4VCMpKYn8dTZv3szhcHJzc+3s7EpLS0+cOFFZWanX6xMTE6Ojo8l+cYdaTk5OfX29Vqvds2fP2bNnMzIy3nzzzSVLlkgkktGjR9fV1eXl5dF2EV9cXHzq1Kny8vL+/v7ExMTZs2fPmzfvxx9/vHHjRkBAgEajOXjw4Pbt2+l5sothWHZ2tkqlam1tTUxM9PX13bJlCznrwIEDS5cuHWzImqHQ39+flJRE1hXasGEDj8f74YcfEELffPON0WhksVh5eXmLFi2Sy+U0BIPjeFRUlFAoLCgoKCgoQAgtXLiQPKAyMjK0Wq3ZbM7KyhIIBDk5Oc+ucPRSLFu2rLW1VaVSJSYmIoRCQkJWr15dVlaWk5MzadIke3v78+fP8/l8W8jZkAjpY2dnFxISghCKiIhACDHboN7f3z8xMfHmzZs9PT0rV65cvHjxgNUC6SQQCH755RdyVDNGTJw40WKxUBVWydO6u7t7SEgI+cMhhGh7sB8QEMDn86n1kif39PT00tLStra2wMDAmzdv0lYVUCQSWX8JZOXn+fPns1gstVotEolKSkqouUONy+WSwZAdFFuPQhoVFUVzfWPqoH7//fcRQtTeO2PGjMLCQpPJtGvXLtpO9HZ2dllZWdYl1Jczfvz47u5u6jei5yhbs2ZNe3s7NUneHw4ODo6Nja2pqUEIJScnx8TEMHjIU6CLNQAAAMMaVJYBAAAwrEEiBAAAMKxBIgQAADCsQSIEAAAwrEEiBAAAMKxBIgQAADCsQSIEAKDy8vJjx44xHQUAzIBECABjiouLpVLppUuXaF7vkSNHfv/9d+sSpVK5efNmmsMAwEZAIgSAMXq9/uHDh2S/bnRKSUnJz8+neaUA2CxIhADYtM7OzpaWlmcs0NbWZrFYni4nCKKlpaW3t/d519jW1tbf3/+87wLg1QWJEAAbdf78+fHjx/P5fJFI5O3tnZeXR81KSkqaNGlScXHxW2+95e7uzuPxVq1aZZ29SkpK/Pz8RCKRo6Pj0qVL9+3b5+rqqtVqEUJubm7t7e0//fSTq6urq6vrl19+Sb3r8uXLY8eOdXd353K5y5cvNxqNdG4vAEyBRAiALTp37tz8+fODg4OvXr36xx9/LFy48JNPPiGHFEAI9fT01NbWJicnZ2dnV1ZWbtq0af/+/UePHiXn3r9/f+7cuSKR6NKlS5WVlTwe76uvvuro6MBxHCF04sQJJyenOXPmKJVKpVJJDebe1dWVkJCQkZFRVVW1bdu2vLy8vXv3MrHpANCOAAAwhHxQV1RU9PSsMWPGTJ8+HcdxqkQmk02bNo18TWavqqoqam5QUNDcuXPJ1xs2bOBwOK2trdTcd999FyHU0tJCTgoEgpSUFOvVffbZZwihkpISqiQyMjIiIuL/3UIAXgUwDBMANgfDsNra2unTp5eUlFCFYrG4sLCQmiTHh6Im33777Tt37pCvq6urQ0NDhUIhNXfu3LlVVVXPXqmDg8O0adOoyXHjxhUVFf1/2wHAqwESIQA2h6wdc/To0V9//fWJWWazmc1mI4T4fL51+ciRI81mM/X2oKAg67nWSXEwLi4u9vb/eVZi/YEAvN4gEQJgc5ycnBBCOTk569ate4G3e3l5NTc3W5doNJqXExkAryOoLAOAzRk7dqyHh8fJkyeJFxo3OyQkpLy8XKVSkZM4jp88edJ6AR6P9wLNKgB4XcEVIQAMu3Tpkk6nsy6JiYnJyspSKBTx8fFffPGFj4+PRqMpKytTq9XWrR0Gs3Hjxv3790dHR2/bts3R0TE3N9dgMFgvQD7/KywsHD16tLu7u7e390veJABeKZAIAWBYdnb2EyWPHz+Oj4+3s7NLT08/fPgwWSgQCNLS0v7JB3p5eZWWlm7cuDEuLs7Z2XnFihUymSwtLY16rLhz585169Z9/PHHer0+OTl5165dL3FzAHjl2L3YvRcAwEsxYKcwLBaLfIHj+L1797q7u8nrNqr8eSkUitLSUgzDXjhOAF5jcEUIAJOendvs7e0DAwNf4GMvXLgQHh7u4OCAEDp9+vSxY8eSkpJeMEQAXndwRQjAa+i9996rqanx8fHRarXt7e3R0dH5+fmOjo5MxwWALYJECMBrqKen59q1aw0NDQih8ePHBwcHMx0RALYLEiEAAIBhDdoRAgAAGNYgEQIAABjWIBECAAAY1v4FUreZ7vjczJgAAAAASUVORK5CYII=", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "pAA = plot_AA_dist(\"model_vs_true_AA\", val_strings, model_strings; title=\"AA frequency: Natural vs Generated\")\n", + "display(pAA)\n", + "\n", + "pLen = plot_len_dist(\"model_vs_true_len\", val_strings, model_strings; title=\"Length distribution: Natural vs Generated\")\n", + "display(pLen)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Natural 'A' frequency: 0.047142480905978404\n" + ] + } + ], + "source": [ + "println(\"Natural 'A' frequency: \", (isdefined(Main, :val_strings) ? sum(count(==('A'), s) for s in val_strings) / sum(length.(val_strings)) : sum(count(==('A'), s) for s in val_strings) / sum(length.(val_strings))))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Natural 'A' frequency: 0.04109772423025435\n" + ] + } + ], + "source": [ + "println(\"Natural 'A' frequency: \", (isdefined(Main, :model_strings) ? sum(count(==('A'), s) for s in model_strings) / sum(length.(model_strings)) : sum(count(==('A'), s) for s in model_strings) / sum(length.(model_strings))))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Julia 1.11.6", + "language": "julia", + "name": "julia-1.11" + }, + "language_info": { + "file_extension": ".jl", + "mimetype": "application/julia", + "name": "julia", + "version": "1.11.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/editflow_code/analysis_notebook.ipynb b/editflow_code/analysis_notebook.ipynb index 03faa2b..662e339 100644 --- a/editflow_code/analysis_notebook.ipynb +++ b/editflow_code/analysis_notebook.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 74, + "execution_count": 1, "metadata": {}, "outputs": [ { @@ -13,9 +13,7 @@ "\u001b[32m\u001b[1m Resolving\u001b[22m\u001b[39m package versions...\n", "\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `~/dev/Flowfusion.jl/editflow_code/Project.toml`\n", "\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `~/dev/Flowfusion.jl/editflow_code/Manifest.toml`\n", - "WARNING: redefinition of constant Main.AA20. This may fail, cause incorrect answers, or produce other errors.\n", - "WARNING: redefinition of constant Main.TOK2ID_AA. This may fail, cause incorrect answers, or produce other errors.\n", - "WARNING: redefinition of constant Main.PM. This may fail, cause incorrect answers, or produce other errors.\n" + "WARNING: using StatsBase.sample in module Main conflicts with an existing identifier.\n" ] }, { @@ -24,7 +22,7 @@ "plot_len_dist (generic function with 1 method)" ] }, - "execution_count": 74, + "execution_count": 1, "metadata": {}, "output_type": "execute_result" } @@ -32,7 +30,7 @@ "source": [ "using Pkg\n", "Pkg.activate(@__DIR__)\n", - "#Pkg.instantiate()\n", + "Pkg.instantiate()\n", "using Revise\n", "\n", "using Random\n", @@ -187,7 +185,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -196,7 +194,7 @@ "train_editflow! (generic function with 1 method)" ] }, - "execution_count": 10, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -244,7 +242,7 @@ "\n", " # 6) Scheduler scaling\n", " den = 1f0 .- P.κ.(ts)\n", - " den = max.(den, 1f-6)\n", + " den = max.(den, 1f-3)\n", " scheduler_scaling = P.dκ.(ts) ./ den\n", "\n", " # 7) Masked state\n", @@ -281,7 +279,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Init process and model\n", + "K = PM.K\n", + "P = FF.EditFlow(K; bos_token=0, gap_wise=false)\n", + "model = EditFlowModel(; d=128, num_heads=8, nlayers=4, rff_dim=128, cond_dim=128, K=K)\n", + "nothing" + ] + }, + { + "cell_type": "code", + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -289,245 +300,2405 @@ "output_type": "stream", "text": [ "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.746237f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.981628f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.213884f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.454155f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.665428f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.873983f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.157003f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 15.275973f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.903381f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.729305f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.102013f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.672424f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.530746f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.67213f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.382526f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.963814f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.835972f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.291992f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.19426f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.382185f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.135967f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.92569f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.028893f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.427214f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 17.69117f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.73476f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.384754f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.658775f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.132454f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.998142f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.203682f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.36901f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.243134f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.106112f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.82871f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.493202f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.290234f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.923895f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.832842f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.057846f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.94542f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.881554f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.718155f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.733717f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.073797f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.92004f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.047007f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.872967f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.382488f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.645565f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.287525f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.113968f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.087315f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.874767f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.860031f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.602049f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.410063f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 10.562942f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.848387f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.861128f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 11\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.541365f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 11\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.236982f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 11\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.957115f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 11\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.865005f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 11\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.583748f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 11\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.02132f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 12\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.584347f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 12\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.580858f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 12\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.981087f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 12\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.591656f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 12\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.066517f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 12\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.051542f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 13\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.067421f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 13\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.05304f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 13\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.487747f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 13\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.222967f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 13\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.143532f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 13\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.575806f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 14\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.158926f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 14\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.09401f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 14\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.851517f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 14\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.892365f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 14\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.7897f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 14\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.985878f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 15\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.019676f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 15\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.797548f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 15\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.55872f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 15\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.278553f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 15\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.254448f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 15\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.536222f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 16\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.821463f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 16\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 17.80231f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 16\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.376482f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 16\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.044758f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 16\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.442654f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 16\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.176807f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 17\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.091465f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 17\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.013334f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 17\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.81593f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 17\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.212975f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 17\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.84259f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 17\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.185429f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 18\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.470398f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 18\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.427452f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 18\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.94579f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 18\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.695702f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 18\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.645878f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 18\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.073719f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 19\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.841595f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 19\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.278421f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 19\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.68238f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 19\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.269619f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 19\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.283346f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 19\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.181093f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 20\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.541328f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 20\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.628794f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 20\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.634392f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 20\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.7462f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 20\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.353523f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 20\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.927622f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 21\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.720219f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 21\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.47013f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 21\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.810509f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 21\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.401003f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 21\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.512375f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 21\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.377796f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 22\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.350807f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 22\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 16.468513f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 22\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.804567f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 22\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.310434f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 22\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.925941f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 22\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.39031f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 23\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.91434f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 23\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.262634f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 23\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.324049f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 23\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.413176f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 23\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.26462f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 23\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.746334f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 24\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.85251f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 24\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.560282f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 24\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.03707f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 24\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.268227f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 24\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.471123f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 24\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.593208f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 25\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.767986f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 25\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.076988f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 25\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.13642f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 25\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.121529f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 25\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.215782f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 25\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.73236f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 26\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.485447f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 26\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.659838f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 26\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.290493f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 26\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 16.489616f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 26\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.764778f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 26\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.014236f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 27\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.763737f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 27\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.692177f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 27\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.253918f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 27\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.51273f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 27\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.86855f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 27\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.306889f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 28\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.108227f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 28\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.949062f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 28\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.045507f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 28\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.165205f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 28\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 12.919155f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 28\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.903103f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 29\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.889954f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 29\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.677599f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 29\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.235676f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 29\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.818413f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 29\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.454956f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 29\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.443413f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 30\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.767849f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 30\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.12367f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 30\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.95783f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 30\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.690418f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 30\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.498676f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 30\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.116188f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 31\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.376179f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 31\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.445965f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 31\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.826906f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 31\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.523788f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 31\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 16.482994f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 31\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.550964f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 32\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.193125f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 32\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.838432f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 32\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.289452f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 32\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.098053f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 32\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.513762f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 32\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.862543f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 33\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 16.810226f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 33\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.037594f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 33\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.468763f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 33\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.604746f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 33\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.249472f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 33\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.916328f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 34\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.879818f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 34\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.453798f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 34\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.617702f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 34\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.713636f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 34\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.131275f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 34\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.763681f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 35\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.138496f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 35\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.24766f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 35\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.000917f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 35\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.266335f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 35\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.831928f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 35\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.104105f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 36\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.901894f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 36\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.866064f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 36\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.89682f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 36\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.663845f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 36\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.070297f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 36\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.728453f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 37\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.615274f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 37\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.564804f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 37\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.089449f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 37\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.273602f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 37\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.159435f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 37\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.562922f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 38\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.734241f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 38\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.008451f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 38\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 8.860302f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 38\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.15115f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 38\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.32642f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 38\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.513498f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 39\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.381474f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 39\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.2743f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 39\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.010727f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 39\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.264381f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 39\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.826624f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 39\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.921288f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 40\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.755466f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 40\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.364662f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 40\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.126223f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 40\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.64931f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 40\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.564432f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 40\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.728107f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 41\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 17.909348f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 41\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.832344f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 41\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.323364f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 41\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.952206f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 41\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.968285f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 41\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.83363f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 42\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.986597f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 42\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.239515f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 42\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.450031f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 42\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.893978f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 42\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.543922f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 42\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.674696f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 43\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.830986f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 43\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.515713f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 43\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.128778f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 43\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.751575f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 43\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.633709f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 43\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.873392f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 44\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.810955f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 44\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.402004f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 44\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.716564f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 44\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 17.452545f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 44\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 16.890793f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 44\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.448315f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 45\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.888472f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 45\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.899237f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 45\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.195805f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 45\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.420376f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 45\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.594948f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 45\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 9.004853f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 46\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.887007f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 46\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.23485f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 46\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.913727f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 46\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.218992f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 46\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.94302f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 46\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.745415f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 47\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.451485f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 47\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.83382f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 47\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.155079f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 47\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.894794f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 47\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.932127f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 47\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.041811f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 48\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.656693f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 48\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.531162f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 48\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.119312f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 48\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.319973f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 48\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.268059f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 48\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.691246f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 49\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.474157f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 49\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.733646f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 49\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.136124f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 49\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 17.320087f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 49\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.540567f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 49\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.147991f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 50\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.83776f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 50\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.327303f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 50\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.39455f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 50\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.208961f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 50\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.616371f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 50\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.594536f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 51\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.58604f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 51\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.868906f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 51\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.821358f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 51\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.95021f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 51\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.622738f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 51\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.146685f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 52\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.15935f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 52\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.340935f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 52\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.693542f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 52\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.80805f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 52\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.283953f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 52\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.714622f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 53\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.754047f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 53\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.48253f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 53\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.189365f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 53\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.135786f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 53\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.220694f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 53\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.33191f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 54\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.619081f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 54\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.133217f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 54\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.216085f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 54\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.81441f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 54\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.997604f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 54\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.05939f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 55\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 16.644253f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 55\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.239815f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 55\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.43597f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 55\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 16.8848f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 55\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.401718f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 55\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.64897f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 56\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.992f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 56\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.69675f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 56\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.861366f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 56\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.179195f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 56\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = -11.587956f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 56\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.98692f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 57\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.81665f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 57\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.926167f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 57\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.971962f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 57\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.27145f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 57\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.326494f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 57\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.14252f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 58\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.31263f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 58\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.074333f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 58\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.830984f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 58\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.307228f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 58\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.105434f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 58\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.807196f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 59\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.067299f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 59\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.049335f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 59\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.681822f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 59\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.253326f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 59\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 17.409986f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 59\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.683414f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 60\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.863966f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 60\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 15.980584f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 60\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.086948f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 60\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.897078f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 60\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.529032f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 60\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.82579f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 61\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.25418f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 61\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.34762f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 61\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.448723f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 61\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.228636f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 61\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.144558f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 61\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.490255f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 62\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.441963f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 62\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.559408f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 62\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.865923f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 62\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.954279f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 62\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.403667f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 62\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.830547f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 63\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.544434f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 63\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.088642f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 63\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 5.486371f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 63\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.702126f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 63\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.829082f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 63\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.889729f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 64\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.04778f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 64\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.33698f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 64\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.940506f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 64\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.096375f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 64\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.802752f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 64\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.215298f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 65\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.598557f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 65\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.455418f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 65\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.71409f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 65\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.750744f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 65\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.510859f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 65\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.624943f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 66\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.001049f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 66\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.153976f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 66\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.199299f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 66\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.778515f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 66\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.019203f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 66\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.27776f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 67\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.881886f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 67\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.737415f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 67\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.321026f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 67\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.270313f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 67\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.653442f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 67\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.653757f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 68\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.06898f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 68\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.069595f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 68\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.993654f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 68\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.809895f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 68\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.706173f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 68\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.573029f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 69\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.283886f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 69\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.783833f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 69\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.422552f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 69\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.811619f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 69\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.002556f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 69\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.116966f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 70\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.023243f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 70\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.249037f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 70\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.984207f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 70\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.499313f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 70\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.772282f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 70\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.921055f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 71\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.7816f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 71\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.670277f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 71\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.296196f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 71\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.030935f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 71\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.194506f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 71\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.43831f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 72\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.557142f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 72\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.490828f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 72\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.104092f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 72\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.674341f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 72\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.07388f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 72\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.306126f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 73\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.135044f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 73\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.159412f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 73\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.045418f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 73\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.40194f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 73\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.572552f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 73\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.981903f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 74\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.257917f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 74\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.122993f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 74\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.006748f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 74\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.172253f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 74\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.008356f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 74\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.84019f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 75\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.151068f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 75\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.485172f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 75\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.153769f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 75\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.290163f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 75\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.762228f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 75\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.199116f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 76\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 17.930504f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 76\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.04787f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 76\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.809868f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 76\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.353975f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 76\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.562157f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 76\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 16.483915f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 77\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.138283f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 77\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.523014f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 77\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.520844f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 77\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.04196f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 77\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.441517f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 77\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.367897f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 78\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.163624f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 78\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.393862f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 78\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.718964f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 78\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.644243f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 78\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.149078f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 78\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.814312f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 79\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.689634f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.866508f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 79\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.949148f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.337425f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 79\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.367867f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.624027f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 79\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.82483f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.402237f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 79\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.520725f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.410057f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 79\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.202583f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.08833f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 80\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.252892f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.47953f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 80\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 15.159396f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.978199f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 80\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.860735f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.085361f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 80\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.8605f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.211655f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 80\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.239311f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.508362f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 80\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.785559f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.466614f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 81\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.13742f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.391834f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 81\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.201006f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.903198f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 81\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.12283f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.485249f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 81\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.324005f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.64059f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 81\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.07745f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.317387f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 81\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.980297f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.682806f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 82\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.204556f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.254333f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 82\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.02835f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.734877f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 82\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.109058f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.537487f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 82\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.364738f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.094929f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 82\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.990543f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.800623f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 82\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 17.01241f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.080275f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 83\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.13777f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.002201f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 83\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.440365f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.30722f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 83\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.415945f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.413658f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 83\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.503819f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.382023f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 83\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.38338f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.645979f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 83\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.304304f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.672878f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 84\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.956491f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.800962f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 84\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.750294f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.22847f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 84\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.575756f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.500309f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 84\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.311935f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.74908f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 84\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.014475f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.878939f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 84\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.903141f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.335938f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 85\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.428278f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.956377f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 85\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.780388f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.555515f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 85\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.00268f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.946405f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 85\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.154623f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.589813f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 85\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.851437f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.090248f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 85\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.045534f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.336586f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 86\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.004948f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.855642f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 86\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.882324f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.779556f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 86\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.414518f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.152008f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 86\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.235622f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.799198f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 86\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.864487f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.729807f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 86\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.815882f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.73042f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 87\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.375402f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.806095f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 87\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.58862f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.405361f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 87\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.178719f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.57449f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 87\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.7638f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.7407f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 87\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.780313f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.59734f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 87\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.892445f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.25967f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 88\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.32611f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.743744f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 88\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.11505f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.98431f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 88\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.70185f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 15.31344f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 88\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 5.3568654f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.085484f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 88\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.881176f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.487297f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 88\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.491331f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 89\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 16.660719f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 89\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.529898f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 89\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.550985f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 89\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.375748f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 89\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.937206f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 89\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.631706f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 90\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 17.535595f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 90\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.669437f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 90\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.55685f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 90\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.808851f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 90\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.87554f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 90\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.389326f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 91\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.405817f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 91\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.464638f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 91\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.111252f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 91\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.999516f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 91\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.218391f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 91\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.187355f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 92\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.420967f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 92\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.060745f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 92\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.60073f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 92\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.225628f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 92\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.36546f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 92\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.678913f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 93\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.350622f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 93\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.95152f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 93\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.601427f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 93\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.351856f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 93\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.845188f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 93\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.619637f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 94\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.598852f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 94\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.265049f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 94\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.088186f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 94\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.131905f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 94\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.927309f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 94\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.709093f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 95\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.480736f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 95\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.990673f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 95\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.88835f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 95\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.45876f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 95\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.846493f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 95\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.63565f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 96\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.12495f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 96\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.763638f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 96\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.331306f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 96\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.594742f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 96\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.491268f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 96\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.579607f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 97\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.1447f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 97\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.514366f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 97\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.976524f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 97\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.168167f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 97\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.450222f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 97\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.13343f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 98\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.17472f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 98\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.017311f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 98\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.751623f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 98\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.171782f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 98\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.81949f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 98\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.225515f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 99\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.012215f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 99\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.367924f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 99\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.439997f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 99\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.901167f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 99\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.113953f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 99\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.226475f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 100\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.480293f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 100\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.56205f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 100\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.577469f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 100\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.884739f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 100\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.706923f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 100\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.287842f0\n" + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.257725f0\n" ] }, { @@ -536,7 +2707,7 @@ "EditFlowModel(\n", " Embedding(22 => 128), \u001b[90m# 2_816 parameters\u001b[39m\n", " Chain(\n", - " RandomFourierFeatures{Float32, Matrix{Float32}}(Float32[-4.5109034 -3.5286963 … 9.479959 7.8329725]),\n", + " RandomFourierFeatures{Float32, Matrix{Float32}}(Float32[4.107619 -1.6246507 … -3.6645346 -1.3967112]),\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " ),\n", " [\n", @@ -561,12 +2732,12 @@ " NNlib.swish,\n", " ),\n", " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.84128517, 0.91182154, 0.7902106, 0.81407046, 0.88709915, 0.84869576, 0.8111447, 0.9638999, 0.81951916, 0.959513 … 0.97480565, 0.95435977, 0.9466715, 0.9285081, 0.83059996, 0.8631903, 0.8982503, 0.81248, 0.93745804, 0.9293885], Float32[0.13203958, 0.018567402, -0.020930668, -0.065880686, -0.035770215, -0.023243738, 0.13661915, 0.0137710115, -0.09455174, 0.034909584 … -0.0066378885, -0.0024478664, 0.018370626, 0.006716863, -0.04433143, 0.010105384, 0.041511886, 0.06463821, -0.013997877, 0.050439943], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.96080273, 0.93640083, 0.9547064, 0.8971493, 0.95765316, 0.92207366, 0.89724094, 0.9440924, 0.94302225, 0.94956416 … 0.94014513, 0.9212964, 0.91572565, 0.9039559, 0.9231686, 0.9042348, 0.9314332, 0.87426275, 0.8752597, 0.9407146], Float32[-0.025268404, 0.0020312557, -0.010115526, 0.020099802, 0.018506693, 0.0025694135, -0.023937318, -0.038941544, -0.038218282, -0.008356358 … 0.0045030406, 0.029052407, -0.039042093, -0.009993242, 0.003901428, -0.0070870365, -0.037610408, -0.06006574, 0.015338725, 0.011129025], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " ),\n", " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.95347655, 0.85093075, 0.85541403, 0.8679154, 0.85436136, 0.8412683, 0.826746, 0.89666367, 0.8665498, 0.91768646 … 0.9459032, 0.9138322, 0.79719085, 0.85915995, 0.9585866, 0.8430982, 0.89407706, 0.9543368, 0.8155376, 0.95562476], Float32[0.020209653, -0.021680698, 0.0071744197, -0.041343026, 0.048593093, -0.0116557265, 0.09416032, 0.0151361115, -0.067125924, 0.036569614 … 0.0006538567, 0.09313936, 0.018986525, -0.11644367, 0.022701394, -0.024896353, 0.06305788, -0.036191218, 0.06055014, 0.01618962], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9615473, 0.97570944, 0.9112915, 0.96853894, 0.9237012, 0.9523371, 0.9733101, 0.9436969, 1.0086424, 0.98759335 … 0.96384525, 0.98503447, 0.9836052, 0.95819885, 0.969784, 0.9607591, 0.9873663, 1.0246212, 0.97779596, 0.963771], Float32[-0.027013712, -0.0054144724, 0.0071041402, -0.015267112, -0.05662798, -0.00019226706, 0.017086789, 0.010009103, 0.004368342, -0.022684177 … 0.008213096, 0.01543913, 0.008588103, -0.042858012, 0.005013047, -0.0087100575, -0.00035417278, -0.0044492367, -3.3963931f-6, -0.0070771035], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " ),\n", @@ -593,12 +2764,12 @@ " NNlib.swish,\n", " ),\n", " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9746385, 0.90401894, 0.9233108, 0.90516967, 0.9392885, 0.95880157, 0.9137542, 0.8942627, 0.91990346, 0.9862433 … 0.9012332, 0.9122359, 0.9246821, 0.91831, 0.90074146, 0.91937083, 0.9343478, 0.9342553, 0.92335767, 0.91536856], Float32[-0.011441811, 3.9953837f-5, 0.057703346, -0.06480208, 0.0011973737, -0.028999029, 0.0056339726, 0.0072447304, -0.010037096, 0.033428676 … 0.020015912, 0.017452257, 0.05325796, -0.01191884, 0.01598513, -0.04324265, 0.015074104, 0.033769086, 0.024682254, -0.024697283], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.94601697, 0.97375804, 0.9406857, 0.953404, 0.95697165, 0.9183645, 0.93461883, 0.93530893, 0.98690313, 0.92145735 … 0.8612234, 0.87250346, 0.98907375, 0.956685, 0.9498322, 0.9437079, 0.9624967, 0.949929, 0.97197264, 0.97001827], Float32[0.0011167054, -0.014636964, 0.0022019444, 0.0121619, -0.013723163, 0.001547043, 0.011414896, -0.0012122085, -0.006493586, -0.021626603 … 0.069353715, -0.012018405, 0.004048702, 0.004974579, -0.017438088, -0.010104225, -0.009309289, 4.483607f-5, -0.012501754, -0.006304365], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " ),\n", " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9765863, 0.9458351, 0.93587124, 0.93339974, 0.8989578, 0.9535084, 0.99510795, 0.9719659, 0.9668408, 0.8564658 … 0.9891558, 0.9667731, 0.9314246, 0.83263737, 0.97911185, 0.9124214, 0.91018444, 0.99932754, 0.802342, 0.9956657], Float32[0.017302666, -0.056315612, 0.037888195, -0.06294426, 0.10148297, -0.0010062818, 0.0024953438, 0.044283886, 0.023858724, 0.05449336 … 0.020952262, 0.07595207, 0.057244256, -0.1274221, 0.039070375, 0.02272039, 0.05660025, -0.028933115, 0.07073173, -0.0027376204], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.97332007, 1.0309724, 0.9687911, 0.97576725, 0.96835095, 0.9971229, 0.993208, 0.9710502, 1.003863, 0.9820828 … 0.982708, 0.92708766, 1.0036467, 0.9794132, 0.99849373, 0.9908135, 0.9964946, 1.0093178, 0.9900424, 0.9617081], Float32[-0.016477505, -0.014338043, 0.040039297, -0.029744757, -0.029461078, -0.041657545, 0.027084501, 0.041064046, -0.025039643, 0.0060120723 … 0.0095715625, -0.0138390735, 0.0026735286, -0.050670695, -0.024575308, 0.006731998, -0.007667666, -6.0379556f-5, -0.0033010722, -0.048479233], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " ),\n", @@ -625,12 +2796,12 @@ " NNlib.swish,\n", " ),\n", " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.96034193, 1.0159357, 0.9689168, 0.9651938, 0.9500553, 0.90168905, 0.83910173, 0.9460418, 0.9834187, 0.94236785 … 0.9693384, 0.9697664, 0.9737863, 0.9381034, 0.86150926, 0.9611176, 0.93992716, 0.9402713, 0.89132005, 1.006154], Float32[-0.01447692, 0.011735456, -0.0020311004, -0.034760233, -0.05172142, 0.057911456, 0.06251694, -0.018139904, -0.047031887, 0.003290893 … -0.01567474, 0.010805595, -0.015121574, -0.023687487, -0.028759452, -0.029005336, 0.05817738, -0.028409438, 0.04294521, -0.004147324], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.94413495, 0.9591206, 0.9815761, 0.9860674, 0.9643858, 0.99948543, 0.95805496, 0.9728332, 0.9892072, 0.93138975 … 0.92429256, 1.0070444, 0.9443377, 0.9681403, 0.9447193, 0.9323913, 0.9746358, 0.99652237, 0.96340334, 0.97654444], Float32[-0.03537166, -0.006217378, -0.007379122, 0.009719772, -0.0314247, 0.016313963, -0.0015389565, 0.021076221, 0.010470716, -0.02639406 … 0.0006755494, 0.005295955, 0.017049158, -0.0132954335, 0.005307746, 0.02653267, -0.008163272, 0.009826559, 0.030178566, -0.0014013725], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " ),\n", " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9365266, 0.9492814, 0.9448586, 0.96640795, 0.99485415, 1.0097846, 0.9969547, 0.90934587, 1.0050943, 0.9689348 … 1.0519694, 0.99240464, 0.97498804, 0.9176811, 0.97813183, 0.97207797, 0.9781743, 1.0189404, 0.9108524, 0.9999426], Float32[0.0152735, -0.09397738, 0.026495976, -0.06649545, 0.05174599, 0.016729476, -0.015519516, 0.03077308, 0.02534834, 0.031068088 … 0.024515463, 0.029270023, 0.024118535, -0.12969638, 0.020150084, 0.034348086, 0.058396515, -0.031155355, 0.07536059, -0.020158395], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.93666166, 1.0321827, 0.9726321, 0.98780626, 0.9613221, 1.0248475, 1.0161513, 0.96915793, 0.9948018, 1.0429728 … 1.0270013, 1.0185184, 1.0062677, 0.9811149, 1.0302101, 1.0181782, 1.0179951, 1.0333631, 1.0274625, 0.9702701], Float32[-0.06427912, 0.002420664, 0.047289338, -0.034010448, -0.03299984, -0.013876393, 0.023457177, 0.020834371, 0.010680823, -0.032694057 … -0.003318202, -0.0250829, 0.027400794, -0.031808987, -0.024685763, -0.00258377, -0.011304101, -0.01021114, -0.0004895934, -0.020227717], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " ),\n", @@ -657,12 +2828,12 @@ " NNlib.swish,\n", " ),\n", " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9972363, 0.97399354, 0.8619699, 0.961095, 0.9606036, 0.9139958, 0.9732229, 0.9583855, 1.0531006, 0.9394396 … 0.9756284, 0.9310381, 0.97951865, 0.92094326, 0.99687564, 0.9567006, 0.9752043, 0.95546454, 0.9057552, 0.98454964], Float32[-0.029275956, 0.0912551, -0.08796287, 0.028532406, 0.039656058, 0.03142834, 0.058119882, -0.0062778257, -0.072126254, 0.012900912 … -0.028987817, 0.04767919, -0.031961385, -0.029327428, 0.0059409034, -0.025743894, 0.004865544, -0.007499804, -0.0074433223, -0.033123918], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.98147184, 0.9223102, 1.0042982, 0.97599345, 0.98011535, 0.9964276, 0.9762427, 0.94932944, 0.96026486, 0.95611215 … 0.9575027, 0.9455124, 0.99811995, 0.9754665, 0.9862882, 0.9942666, 0.9694813, 0.96348906, 0.95470506, 0.9039463], Float32[-0.014831864, 9.283005f-5, -0.008477221, 0.040162712, 0.022272639, 0.0436828, -0.009014154, 0.055058725, 0.030263849, -0.040652655 … -0.010325852, -0.023909276, 0.009594226, 0.00861934, -0.0045753345, -0.015833346, 0.019944627, 0.011142825, 0.025711212, 0.026980491], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " ),\n", " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9899853, 1.0113794, 1.0489874, 0.9276706, 1.0521827, 1.0159994, 1.0239544, 1.0025413, 0.93732625, 1.038729 … 1.0678216, 0.930407, 0.9801097, 0.76677334, 0.94644517, 0.9789134, 0.98342764, 1.0859528, 0.91786045, 1.0444598], Float32[0.005111467, -0.05680973, -0.033371042, -0.0843999, 0.08355269, 0.021003177, -0.013964859, 0.007897407, 0.036769442, 0.05594361 … 0.012858942, 0.022676993, 0.057679325, -0.21971306, 0.023857664, 0.030711865, 0.11079519, -0.04627623, 0.107559755, -0.037148476], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9566518, 1.0749155, 1.0178746, 1.0410086, 1.0265093, 1.0722593, 1.0385908, 1.0496945, 1.1038729, 1.003326 … 1.0357652, 1.005023, 1.0573806, 1.0052382, 0.98908836, 1.0178303, 1.110416, 1.0397507, 1.0142217, 1.0475482], Float32[-0.08760491, 0.051100586, 0.08073487, -0.080240734, -0.037350997, -0.064348176, 0.01896439, 0.012915793, 0.041853514, -0.02849257 … -0.012428334, -0.040537376, 0.026203565, -0.026402708, -0.039873, -0.0071864277, 0.023559058, -0.015315336, 0.05209827, -0.06641875], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " ),\n", @@ -676,234 +2847,221 @@ "\u001b[90m # plus 3 non-trainable, 65_600 parameters, summarysize \u001b[39m5.364 MiB." ] }, - "execution_count": 70, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# Init process and model\n", - "K = PM.K\n", - "P = FF.EditFlow_cubic(K,; bos_token=0)\n", - "model = EditFlowModel(; d=128, num_heads=8, nlayers=4, rff_dim=128, cond_dim=128, K=K)\n", - "nothing" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "model = train_editflow!(P, model; epochs=10, steps_per_epoch=150, batch_size=256, lr=3f-4)\n" + "model = train_editflow!(P, model; epochs=100, steps_per_epoch=150, batch_size=256, lr=1f-4)\n" ] }, { "cell_type": "code", - "execution_count": 71, + "execution_count": 19, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlgAAAGQCAIAAAD9V4nPAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nOzdd0AU1/428LONXXpHuigIGksE7AVFwaBRE4MlGstVY4w/I5bcmFjDjbFFY25MbDEWsMUSe8FegyKigIJIB+m9w9Z5/5ibeTdLERZ2Eeb5/LU7e87Md2fLszNzZpZDURQBAABgK25rFwAAANCaEITtSllZ2fz583/44Yemdty/f//cuXMTExM1UVVbFxcXN3/+/IcPH7Z2IS1v4cKFy5YtY+6mp6fPnTt3165d2ll6ZGTk/PnzT506pZ3FvW1ycnLmz5+/fft2jS5FLBbPnTs3MDCwqR1fvHgxf/78x48fa6Cotw8FGlNSUsKs5+jo6NoNtmzZQj86aNCgFlliTk6OenObOXMmIeT+/fstUkbjzZs3T9AIL1680HJhyvz8/CwsLMrKylqxBg3R19e3srJi7j59+pQQ4u/vr52lnz59mhDy73//u+FmFhYWAoEgMzNTO1VpzcuXLwkhfn5+b2z5+++/Hzp0SL2llJeXE0J69erV1I4ymczV1dXd3V0ul6u36DaEr/XkZR0Oh0NR1KFDh2pvqB08eJB+tFUKext06dJl8ODBzN2SkpLIyEgDA4M+ffooN9PT09N6af8TEhISEhKyZcsWQ0PD1qpBawwNDYcPH96jR4/WLuQfJBKJVCpl88dk4cKFZmZm06dPV6Mvn88fPny4i4tLUzvyeLwVK1bMnj372LFjn3zyiRqLbkMQhBpnZmZma2sbHBy8YcMGPv//r/Dw8PCYmJihQ4fev3+/FctrXV999dVXX33F3L1z5463t3eXLl1u377dilUp27p1q0Ag+Ne//tXahWiDi4vL27PmoUWIRCK1X9OPP/54yZIlW7ZsQRBCC5g+ffrXX3997dq1MWPGMBMPHjxICJkxY0adQahQKEJDQyMjI6VSaadOnXx8fAwMDGo3y8rKCgkJKS0tdXFxee+99xqoITIy8vHjx2VlZXZ2dr6+vhYWFk16Cq9fv87Ly+vYsWPtjunp6fn5+coPxcXFRUZGZmVl6evr29nZDRo0yMzMrEmLY8jl8sjISF1d3Xfeeae0tDQkJCQjI6Nv375eXl4pKSlFRUVdu3bV19dn2lMU9fTpU5FI1L17d5VZvXz5MjQ0tLCw0NbWduTIkTY2Nm9celJS0q1bt8aPH6/yrCMjIwkhvXv3rqmpuXz5ckpKioWFxahRo+qcZ35+/o0bNzIzM42MjAYOHNizZ0/lR6VSaXR0tIGBgZubW3Fx8ZUrV7KysoYMGTJgwABmKZWVlZcvX87IyLC3tx83bpxIJKL7hoaGRkRE8Hi8UaNG1f7JX1NT8/Dhw9TU1Pz8fBsbm6FDhzo5OTX8fKurq2NjY01NTTt37kwIqaioePXqVZ0tLSwsOnbsyNxVKBQPHz6MjIwUi8WdOnXy9fWt8+364sWLu3fvKhQKd3d35T0BLaKiouLmzZspKSk8Hq93796DBw/mcv83BqKwsDA1NVWlZuWHLC0tHR0dmYlVVVU3b95MTk7mcDi9evXy8vJiZkUIkUgkz58/Z16yy5cvZ2dnOzo6+vn5GRkZqcw/JSXlyZMnGRkZQqHQxsZm4MCB1tbWtYsvKCi4cuVKbm6uk5OTn58fs/aKi4uTk5MpipJKpREREfREQ0NDV1dXpm9lZSX9xLlcbq9evYYOHapcrUKhePbsmZ6eXrdu3egpRUVFKSkpNjY2tra2ycnJN27cqKys7Natm6+vL4/HU65KJBJ99NFHBw4cCAsL69+//5tfg7arVXfMtnP0MUJzc/OcnBw+nz958mTmIbFYbG5u3q9fP3oIhspRvfj4+N69eyu/TBYWFqdPn1aZ/65du5jvREKIi4vLnTt3as8tLS3Ny8tLeW76+vo7d+5UbvPGY4RHjx4lhMyePbv2Q3Spz58/pyiqpqZm6tSpKu8xHo/3+PHjxqwx+qeru7s7M6WsrIwQ0qtXr3PnzhkbG9MzXLBgAUVR9K/Uhw8fKs9BJpMRQlxdXZUn5uXlKf8EIYQIhcL169e/sZ7vv/+eELJ7926V6aampiYmJk+ePHFwcGDmqaenV/s12rx5s66urvKix44dW1xczDTIzMykX7Jjx44xX3/Lly+nKMrExMTExCQ0NFT5q9PJySk5ObmoqMjHx4eZKBAI9u3bp7zcnTt3quxP5nK5CxculMlkys0aPkZ47969Wl8Y/zN37lymV0REhMrPDktLywsXLqi8LvPnz+dwOEybkSNHBgUFkUYcI6TTJSMjo4E2+/btU/mx5eHhkZKSQj8aHx/P4XC6d+9eu+Onn35KCAkODmamHDp0SOV3T69evRISEpgGr1+/JoQMGTLk7NmzysnXoUOHp0+fMs0UCsXixYuVnzIhhMPhnD17lm7AHCM8duyY8otlb28fExNDt/njjz9qr/wRI0YwSwkKCjI3N1d+9N13301MTGQa1D5GePjwYULI6tWr16xZoxyZ/fr1KyoqUlk/9FCmpUuXNrDy2wEEoQYxQUhR1JgxY3R0dAoKCuiH6Pf3jh07agdhUVER/fU6e/bsiIiIuLi4LVu2iEQiHo93+/ZtptmlS5c4HI6ZmVlQUFB6evrjx4/ff/99Ozs7lbkVFhY6OTlxOJy5c+feuXMnLi7uyJEj9vb2hJCTJ08yzd4YhNXV1SYmJvr6+uXl5crTnz9/Tn+E6Lv08B9vb+9bt26lp6fHxMScP39+1qxZERERjVlj9QWhhYWFvr7+F198ceHChfv379+6dYtqdBBWVlbSG2FTpky5efNmXFzcn3/+2aVLF0KIyq+B2nx9fQkhUVFRKtNNTU1FIpG1tfXMmTOvXbv2+PHj5cuXc7lcIyMj5ZD75ZdfCCHW1taHDh1KSEi4d++et7c3IcTLy4sJJDoIra2tdXV1ly1bdvny5bt37967d4+iKBMTE5FI1KFDh/nz59++ffvBgwcTJ04khIwaNWrcuHEeHh6nT5+OiIjYunWrjo6OSCRSHk7y7bffzpo168yZM5GRkbGxsX/88QedVRs2bFB+Ig0HYXFx8fV/unbt2jvvvEMIWbNmDd3m1atXRkZGQqHwm2++efjw4YsXL3bu3GlsbKyjo/PkyRNmzqtXryaEvPPOO9euXUtPT6fnY2tr2yJB+PvvvxNCbG1t9+7dGxUV9fjx40WLFnE4HDc3t8rKSrrNoEGDCCEq70P6XW1gYMC8q48cOcLhcDp06LBr167IyMjw8PAvv/ySy+V27tyZGS1FB6GNjY2BgcHXX3997969+/fvT5s2jRDSvXt3hUJBNzt27Bidx5cuXUpLS4uLiwsJCfm///u/K1eu0A3oILS3t9fX11+7du2DBw/u3LkzYcIEQkj//v3pNjk5OdevXxcIBGZmZsyrwDyL4OBgDodjbW29e/fuqKio8PDwpUuXcrlcZ2dn5hnVF4SdOnUyNzffsWNHeHj45cuXPTw8yN8/MZXR708PD4+GX6O2DkGoQcpBePz4cTr56If8/PzoXKwdhGvWrCGEjB8/XnlWO3fuJIR4enoyU+gv93PnzjFTJBIJ/WWnPLfFixcTQlauXKk8t7i4OB0dHRcXF+ZD25hRo5999pnKb2eKoujB98zzGj16NCGE3pmjhvqCkPy9kaSskUFIb9XNmzdPuVlWVpahoaGlpWVNTU0D9RgbG3O5XHqkhjJTU9Pa3xqTJk0ihBw/fpy+W1FRYWJiQggJDQ1l2lRXV9MZfOrUKXoK/UVDCFm3bp3KUujuAQEBzBSxWExvHTo5OVVVVTHTFyxYQAj57bffGnguOTk5pqam1tbWzItONX3U6IoVKwghw4YNE4vF9BT6FQ8KClJuFhISQggZM2YMfbegoEAoFAqFwtevXzNtMjIy6P0ZzQzCkpISIyMjQ0PDpKQk5ekBAQGEkF9//ZW+u2fPHpWVSVHUkSNHCCFz5syh71ZUVJibm+vp6cXFxSk3W758OSFky5Yt9F06CJXf9hRFKRQK+icCszE3b968hj9TdBCqrD2pVErvwU5LS2Mm0rtVVbqXl5ebmprq6+vHx8crT//yyy8JIdu2bWOa1RmEfD5f+Rdeenq6jo6OpaVl7TrNzc15PF51dXV9T6QdQBBqkHIQisViCwsLesspMzOTx+PRe0prByE9Zk/525OiqJqaGisrK0JIamoqRVEJCQn0173ylxpFUb/99pvy3BQKhYWFBZ/Prz30n/7+evXqFX23MUH4119/EUJGjhzJTJFKpdbW1spbuvTv4iNHjjR+LSmrLwg5HA6zCEYjg7Br164qXys0+ik/ePCgvmIqKyuZl08FHYQqeU+v/E2bNtF3z58/TwgZPny4Sl/6N820adPou3QQCoVClU1t6u8gpF9xBr3FwCyFRm98rFixor7nQqNfdOUZNikI9+/fTwjp1q0bswMtPz+fw+E4OjrWbuzs7CwUCunfGcHBwYSQmTNnqrShhyA1Mwjp/auff/65ynQ6Zt5//336bmlpqZ6enrm5ufJPn1GjRhFC7t69S989ceIEIWTWrFkqs0pNTSVKOyTpIDQyMlLZz0xH78WLF+m7dHz+8MMP9T0vukKVnyYURc2ZM4cQcufOHWZKnUFIv+hMijOSkpIIIb6+vvTd+oKQWTOMd999lxBS+33o5uZW5yeoPcFgGS3R0dGZMmXKjh07nj9/funSJblcXudARIqiXr58yeFw3N3dlacLhcKePXvevHkzNja2Y8eOsbGxhJBevXqpHIFQObL4+vXrgoICU1PT9evXqyyIPuMwNTVV+ah7wwYNGtS1a9dbt26lpKR06tSJEBISEpKTkzN58mTmKAUz2Hr79u3vvfeet7f3kCFDlMfKqsfa2lrlQEgjVVVVvXr1SigU0vGjjP6+SE1NrW/URnFxMSGEOTCpQiQSqYy86NChA/l7xRJC6K85eo+TMk9PT0JITEyM8kRHR8c6R5eIRCLlQRyEEEtLS0II/d3EoH8k5ebmMlMUCsXBgwcPHz6ckJCQm5srlUqZhwoLC2uPGXmju3fvfv755xYWFufPn6d/BxBCnj17RlGUQCD45ptvVNrLZDKxWJyTk8O8XenvWWUqb1f1PHv2jBCSlJSkUgP9k4jOMEKIkZHRhx9+ePTo0StXrnz44YeEkKysrJs3b3bq1Gno0KHKs0pPT1eZFUVRHA6HmRXNxcVFZWgJ/QZgXoXp06f/97//Xb58+eHDh0ePHj18+PDhw4crH9Snubq6qnyKVebT8BNPTU1VqVahUNSutjaVtxBRegOrDLyiX+7CwkKVt2J7giDUnlmzZu3YsePQoUMXLlywtbWlf42qqK6ulsvlxsbGtT8w9NuU/n1XUVFB/v76U6Yyhd4kLS8vpzdWVJiamtJfFo03Y8aMVatWHT16dNWqVYQQ+sf4rFmzmAY+Pj43btxYv379vXv3wsLCvvvuO1NT09WrVy9ZskT5sHxTNXWMK6O0tJSiKJlMVt8akMvl9fWlTxyktwtrE4lEKs+Ivkv9fbpbw68R/Toy6nuCIpFI5VuSXorKABy6DaV0pt3nn3++d+9ea2vr999/39bWlh5Ye+zYsaioqKa+6ISQly9fTpgwgcfjnT9/Xvlbkn6DZWRk1Ld6xWIxafTbVT10DQ8fPnzy5EntAgQCAXN31qxZR48eDQoKooMwODiY/j3KrGF6Vo8fP6bH6yozMTFRnhWp69xWej4KhYK+27Nnz4cPH65du/bmzZvR0dGbN282MDBYvHjx2rVrdXR0GpgP/RIz82n4iYeFhdGJ2HC1tdW3XKrW+Zr0e7X2gNj2BEGoPX379u3Ro8evv/5aXV29fPlylZ+TNF1dXXpPZk1NjUoW0psa9NuR/o6u/ZtRZQrdrGPHji117bRZs2atXbs2KCho5cqVxcXFFy5c6NChg0qijxgxYsSIEaWlpffv3798+XJwcPCXX36po6PzxRdfqL1clTBQnqjyfaGSW/QaMDQ0LCwsrHMmDaDHgNDbhWqgF52Xl6cynX6NVL5Wmlpbw+Li4vbu3du1a9ewsDDlBdGH7pqqoKBg/PjxJSUlR44cGThwoPJD9HMcMWLE5cuXG5hDI9+u6qFnvmnTpoULFzbc0sfHx8HB4dKlS/n5+ZaWlvRIE+Wz1OlZBQYG/vvf/25+YYQQDw+PixcvVlZWhoaGXrt2bf/+/evXr5fL5Rs3bmz+zOlq161bt3Tp0ubPrQH0R4DeFdFe4VqjWjVr1qzq6mpCSH0naHM4nHfeeYeiKOacIVpNTU10dDQhhD6CSA+KiYqKUokB+hgPo2PHjmZmZsnJycz+umays7MbOXJkQkLCw4cPjx07JhaLZ82aVeeeT2Nj47Fjx+7cufPMmTOEEE1cT5IeNqLyZUrvhWMYGBh06dKlpKREZVdkI/Xo0UMikbxxL1Od6Neo9mZKeHg4+ft11JCoqChCyJgxY5RTUCwWq7ESqqurx48fn5iYuHnz5tonxvTu3ZvD4YSHhyvveq2NfrK1N1xU3q7qoQ8ihIaGvrEll8udMWOGVCo9duxYWFjYy5cvvb296TMmmzqrJtHX1/f19d2yZQt9xrAanwWBQFB7O15D1aooLS3Nycnp1KlT+94iRBBq1bx5865fv37nzh3m5Nba6CHymzZtUp64d+/egoKCgQMH0mc+dO7c2d3dPTEx8ezZs0wbiUSicgFfLpdLj1CgR42qLIjeYdVU9I7QoKAger+oymWfas+TPsec3kXWsuivMOWtHIqiVNYb+fs3x6pVq2rvBX3jGhg2bBghJCwsTI3yvL29zc3N7927Rw8yolVXV//000+EEHqIqYbQP97T09OVJ/7yyy/5+flNmg9FUXPnzn348OHcuXOVLwDEsLa2Hj16dEFBwY8//lj7UWb1jh49WldX9+TJk2lpacyj6enp9OCUZpowYYKJicmpU6dq/+YgtV5iekco8+5V3qtPCBk7dix9EFT5JatvVm9U52eBw+Go8Vmws7MrLi5W2dsxfvx4c3Pzs2fP1nk5ePU+3bWFh4crFAr6g9COYdeoVhkbGyufB12nxYsXHzhw4OLFi9OmTVu4cKGhoeH58+fXrVvH5/O3bt3KNNu8ebOfn9+cOXPy8vK8vb1zcnK+//772ge0AgMDQ0JCDhw4kJmZOWfOHPrMquTk5MuXLz979iwuLq6pT2HChAnGxsaHDh2qrq7u27evynVSvLy8XFxcPvzwQxcXFyMjo/j4ePqy95MnT27qgt5o/PjxX3755b59+8zNzceMGZObm/v777/TQ2CULVu27Ny5c+fPnx82bNiCBQu6du0qlUpTUlKuXbt2+fLlhvfOjRs3btu2bbdv354yZUpTy9PV1d24ceNnn302YcKEDRs2DBw4MCMj47vvvktOTvbx8Rk3blxTZ9h4np6eRkZGf/7559q1a+khoCdOnPjxxx+dnJyatHW7Z8+eY8eOWVtbjxw58uTJk8oPderUib4e7K+//tqvX78VK1bExMR89NFHLi4uhYWFSUlJf/75J0VRV65cIYSYmpquXLlyzZo1vr6+P/zwQ/fu3WNiYpYvX96hQweVtG7A6tWrlS8hRPvggw98fX137Ngxffp0b2/vL7/8cvDgwdbW1q9fv46JiQkODv7000/pM4hoXbp0GThwYGhoaFxcnKGhob+/v/LcDAwM9uzZM2nSpFGjRi1dutTLy8vGxiYzMzM2NjY4OPjjjz+uPSaoAZMnT+ZwOJMmTXJ1dbWwsEhJSaHH+qrxWejTp8+rV68mTJgwevRofX19W1vbsWPHGhoa7t69e8qUKT4+PsuWLRs6dKiNjU1GRgZd7fTp0+v87dJU9DU63n///ebP6q3WCiNVWUP59In61HllmZSUFJWDMXZ2dpcvX1bpe/DgQeWvhm7dutG/ZFXmlp+fP3nyZJWRHXp6esoDr5v07xP0CYXkn+dR0caPH6+yIB0dna+//rqRF7Bv4MoydbZXuSRHjx496EuCqVxZpqysbM6cOSq7cIVC4QcffPDGkt555x1TU1OV0w3pK8uotLxw4QIhZPHixcoTf/nlF5WrdU+ZMkX5bBbmyjK1F01fWUZl4ueff04ICQkJUZ5469Yt8s/r/ly4cEF5X5auru6+ffvofZthYWFMs4ZPn/jPf/5T3/eG8pVlEhIS6AsFKDM1NQ0MDGTaKBSKpUuXKh8KHTNmzKFDh0ijT5+o08aNG+k2586do0cyK3N2dr569arK3OgTCkldJx7Qrly5Uvt6dZ06dTp//jzdgLmyjErHDRs2EEL27t1L3/38889V3nJcLvfTTz9l3kv1/fsEPRLt2LFjzJTMzEwfHx9mbspXlrl06ZKzs7NKtZ07d2bO4mjgyjIqy/Xz8yOEKJ+VqFAoOnfubG1tLZFI6lxX7Qar//pA0xQKRWpqKo/Ha2C0ulgszszMFIlE9FU2GBRFRUZGRkVFicViFxeXIUOGCIXC2t0LCgpu3LhRVlbm7Ow8bNgwDoeTlpZWe26EkKysrNDQ0IKCAkNDQwcHhz59+ihHSG5ubllZmYODQ+3RqrWVl5fTO9ns7OxqV1VYWBgREZGdnS2TyRwcHDw8PBo/5rO6upo+z5q5dBm9DnV0dOh9wrXl5eXduHGjvLzcxcVl+PDhPB4vOTlZIBAoX/yMaRkaGpqTk6Ovr29vb09vNr2xpB07dnzxxRcnTpxQ3plJb1epXLqzqqoqJyfH2NhY5UyP0tLSu3fvZmVlGRgYDBw4UOVrSy6X1/eS1bmUgoKCsrIyGxsb5YGj1dXV2dnZ9CUCmInFxcUPHz58/fq1paXliBEjTExM8vLyKioqlF+1pKQkLpfLRIhYLE5PTzc0NKSPvxYXF9c3VkhlWYSQhISE8PDwsrIyMzMzR0dHT0/P2gMXk5KSHjx4IJfLe/Xq1adPn8rKytzc3NprTEVycnJ9g3stLCyYczlkMtmTJ0/i4uIkEom1tXWXLl3qPAAhkUgyMjLovvW9AeRyeURERGxsrFgstrGx6dy5s/IxXZlMlp6eXvslKykpKSoqsrS0ZH76lJeXh4eHZ2Zm1tTU2NnZubu7K1+NViqVvn79Wk9PT+Xqo0VFRSUlJVZWVipn1Mjl8pycHLFYrKurqzwflWqdnZ2Vr3hHUVRiYqJQKGROfqioqMjLyzMxMVG5KF1OTk5VVZWDgwPzwtEXwQ8MDPz222/rXFHtBoIQoCFSqbRHjx5CoTAyMrI5Z4AAtDk+Pj7Pnz9PSEho3yNlCAbLADRMIBBs3bq1srLy7t27rV0LgPZER0fTxzXbfQoSbBECAADLYYsQAABYDUEIAACshiAEAABWQxACAACrIQgBAIDVEIQAAMBqCEIAAGA1BCEAALBaG/j3ievXr+vr6w8aNIiZolAomn+xK5lMllNULn3Dv0DXy8pIqF/rL57bN4qiWvb/Y+GNWuStDk2F1a59rfv10gaC8ObNm6ampspBWFlZqXJFfzXk5uau3HVCt+sQNfoWZ6VM7244/v3RzayhDZHL5WKxWI9l2d/qWuStDk2F1a591dXVQqGQx+O1ytLbQBBqjlBX36abhxod5TIpIaUtXg8AAGgfNv8BAIDVEIQAAMBqCEIAAGA1BCEAALAaghAAAFgNQQgAAKyGIAQAAFZDEAIAAKux+oR6AIAWFxQU9Msvv7R2FW1MYy6x1qlTp5MnT2pi6QhCAICWFBMTM2TIkBkzZrR2Ie1KUVHR9OnTNTRzBCEAQAuzs7Pz9PRs7Sralby8PM3NHMcIAQCA1RCEAADAaghCAABgNQQhAACwGoIQAABYDUEIAKBZixYv4WiLQ8dOrf10/4eiKKlU2tpVNApOnwAA0KySsvLxa/e6j5+t6QVVlxXt/qirysTt27f/9ddfO3fuNDc3J4S8fPny559/3r17d30zefbsmVAofOedd5pZzI0bN1asWPHkyZNmzkcLNBiEly5d+uOPP3R0dD7//PO+ffuqPJqUlLR3717m7ieffNKzZ0/NFQMAwE6PHz8+ffq0o6Pjli1bCCEFBQUXL15soP3+/fstLS3Xrl2rrQJbn6aC8OrVqzNnzvz555+Liop8fHzCw8NdXV2VG6SlpQUHBy9evJi+q6Ojo6FKAABYbubMmXv37g0ICHBwcFCefv/+/fPnz+fn57u6ui5cuNDY2PjZs2ehoaF6enpVVVXdu3efNm3aqlWr1q1bJxAICCFHjx51dnbu37///fv3c3JyuFzuhQsXFixY0KFDhyNHjiQkJFhYWMyePbt79+6t9ETVpKljhNu2bVu1atX06dMDAgImT568a9eu2m06dOjw9d/c3Nw0VAkAAMt17Nhx+vTp69atU5n+4MGD3r17T506NTMzc9SoURRFmZmZWVlZ2draenp6Ojs7y+XyzZs3M4f6zp8/HxkZSQgJDw8PCAi4cuXKuHHjTE1Nnz17ZmxsPHXqVCcnp+HDh6elpWn7GTaPprYIHz9+vH79evq2l5dXnUGYm5sbEBBgbGw8YcIEDw8PDVUCAABr1651c3NbunSp8sQVK1ZQFJWbm9ulS5fBgwcnJSW5uLi4uLhYWlpOmjSJECKRSOqboZWV1e+//07fpnf4lZaWdunS5a+//jp79iyzt69N0EgQVldXl5SUmJmZ0XctLCxycnJU2piYmEydOtXV1TUxMXHYsGH79++n13tt8fHx0dHRV69epe+KRKItW7Z07NixmUVWVlZKpdIGXuYGSGXS6pqaioqKZtbQhsjlcrFYrFAoWrsQdqmsrHzjJfmhxTVztb+dQyWtrKz+7//+79tvv120aBEz8Ycffvjll186deokFAorKiqys7NdXFwaOUPlUR137tz57LPPjI2NTUxMEhMTm//9XCeKotT41hWJRHz+G5JOI0EoFAr5fL5YLKbv1tTU6OnpqbTx8PBgtgI7duz4/fff1xeEdnZ25ubmU6ZMoe/yeDw7OzsDA4NmFqmvry8QCNQ7NingC3RFoubX0MDYm0cAACAASURBVIbI5XKBQFD7dQSNoiiKVW+zt0QzVzt9OO0ttHz5cmdn5379+tF309PTN27cmJKSYmJiQgixtbWt/UuXx+NxuVwm2svKypiHlJ9mQEDAtm3bxo4dSwiZN28eRVGaqJ/D4Wjo46CRY4RcLtfW1pbZTZyWlqZyhFZF9+7da28yMvT19V1cXHz+5u3tzePxWrhiAID2ztjYePny5fTYUUJIVVUVh8Ohv06PHz+enZ1NT7ewsMjIyKBv83i8Tp063bt3jxDy6tUr+kZtVVVV9EZFenr66dOnNf1EWpymBstMnDgxKCiIECKVSo8ePTpx4kRCiFwuDwoKKi4uJoQwK52e2KdPHw1VAgAAtICAAGY3WNeuXT/44AM3NzcPD48///yzW7du9PQZM2Y8e/bM2tqa/kvFzZs3z5w5s2fPngsWLBg8eHCdsw0MDJw6dWr//v0nTJjg4+NDT+RyuW/cJ/mW0FSVX3311YgRI/r3719eXm5ra/vJJ58QQsRi8b/+9a/IyEhTU9Nvv/322rVrTk5OKSkppqamf/75p4YqAQBoXVwOJ/LPPa/Drmp6QXKphMtVPbp5+PBh5rZIJHr9+jVz98CBAwUFBRRFWVpaMhM7d+4cHh7O3PX39x87dmx+fr69vT0zcdmyZcqLmD59+kcffVRYWGhvb88cXh05cuTIkSNb4mlpnKaC0NraOjo6+unTpyKRqGfPnvSq0dPTy8rKotf4nj174uPjc3NzbWxsnJ2duVxc7A0A2qeVX381NjpaO8uysFjSxPYWb2wjFAqVU7BOenp6bXcMgQa3W/l8PnNUlmFjY0Pf4HA4bm5uOH0QANq9zp07W1lZaWdZQqFQOwtqT9rGDlwAgLZr2ZLF+/cf0NHR+GhSiiKGhoavMzM1vSBNq6qq4nK5IpFIO4tDEAIAaFZlZeUPn0+fPspL0wsqLq/0nP9N7ekURR08ePD48eMZGRmWlpb9+vVbsGCBk5OTputhnDlzpm/fvm/cv8r45ptvLC0t16xZo9GqGDgyBwDQzn366afr16+fM2fOqVOn1q1bx+fzV69erc0CNmzYEBsbq80lNgm2CAEA2rN79+4dOXLk5cuXnTr9768KhwwZUl1dTd8Wi8U7d+6MiIjo0KHDkiVL6HO+9+zZ4+HhceHCBfrKX5999hk94LGgoGD79u1JSUlubm7Lli2jT29fu3btxIkT9+7dy+fzf/rppwMHDjx48KCmpqZPnz4LFy7U0dE5d+5cRkbGvn37bt265efnN3z48LKysu3bt9MlLVu2jL4MWU1NzdatW58/f+7t7a3li1hhixAAoD27fPny0KFDmRSk6erqEkIoihozZkxsbOy8efMcHR0HDRpUWlpKCDl69OjMmTOdnJw+/vjjTZs2HT9+nBBSWlrat29fkUg0f/784uJiPz8/+goyP/3007x58wYNGjRmzBhCSHx8/KRJk+bNm3f79m36cm5du3Y1MjLy8PDw8fFxcnKqqakZMGBAVVXV/PnzuVzusGHDZDIZIWTatGmRkZELFixIT0//448/tLmKsEUIANCe5eTkMAfnsrOzAwMDCSHGxsY//PDDrVu3srOzb9y4weFwhg0bFhYWdvLkyU8//ZQQMnv27Dlz5hBCYmNjb9269fHHH//222+DBg1auXIlIWTo0KHdunV79uwZfaXMNWvW0NdXI4Rs3LixoqIiLy9v5cqVY8eO3bNnj5ubm5GRkbu7O32u/f79+x0dHTds2EAI8fLyunHjxu3bt7t06XL9+vWsrCxDQ8Phw4ffvHlTm6sIQQgA0J4ZGxsnJyfTt0Uikaen56tXrw4fPvzDDz/Exsbm5OQwf5xeVFTE/DF9ly5d6Bvm5uYRERGEkJcvX969e5e5Clh5eXlmZiYdhEwviUQyffr06OhoFxcXoVBYWFgokUhULun88uXLyMhIZj65ublZWVlcLrdjx46Ghob0xF69emlmZdQNQQgA0J4NHjz46NGjZWVlRkZGpqamn3322e3bt48dO0YIMTc379Wr1507d2r3qv3/G2ZmZpMnT962bVvtxsyl1M6cOZOTk/Py5UsOh5Oamnr69OnaF+A2MzN777336GtwMp4+fVpSUsLcLSoqcnR0bPJTVReOEQIAtGcTJkzo2LHjjBkzmP82YK6p7ePjExMTc+nSJfpuVlYWcxXo2iZOnHj48OG4uDj6bmxsLDPihiGRSORyOUVRFEUxV/cmhFhZWTFbpR9++OGFCxforUxCSGJiYmlpaY8ePXg8Hn2tzfj4+JCQkGY+6yZBEAIAtGcCgeDatWtmZmZdunSxtbW1tbX99ddfd+zYQQixsrI6e/bsqlWrXFxcnJ2dR4wYkZeXRwgxNDRk9mcKhUJ9fX1CyIABA/773/+OGTOmW7duDg4Os2bNov+eycTEhLlGpr+/P5/Pd3JycnNzs7GxMTU1pacvX7589+7dTk5Ou3fv7tatW1BQ0LRp09zc3Dp27Dhp0qSKigodHZ0jR44sW7asa9euM2bM+Oijj+jhPNrB0dAfR7Wgb775xtTU9Ouvv2amlJeXM7uS1ZaZmRl48JKd31w1+mY8DxtvWTr+/dHNrKENof+Yt+1eS7CNapG3OjRVM1f78uXLLS0tv/rqK2bKp7NnP3v0V0ebDi1RXUMkMtmjF68KiorqfFQmk5WWlpqYmNT+Jzv6v4gb+QEvKysTCoUNXMutrKxMR0fnjdeFKS8vFwgEKs2KioqYP3VXlpeX17Nnz9zc3MZU2FQ4RggAoFkr16xh9gRq2gpb2/oe4vP55ubmdT5Eb/M1kpGRUTMb0Or8tVFnCmoaghAAQLM6d+7cuXPn1q4C6oVjhAAAwGoIQgAAYDUEIQAAsBqCEAAAWA1BCAAArIZRowAALUlXV/fbb7/duHFjaxfSrlAUZWxsrKGZIwgBAFrSmjVrlixZ0tpVtDHV1dU6Ojq1z/RX1sAp/M2EIAQAaEl8Pp+5tBg0En2pmoaDUHNwjBAAAFgNQQgAAKyGIAQAAFZDEAIAAKshCAEAgNUQhAAAwGoIQgAAYDUEIQAAsBqCEAAAWA1BCAAArIYgBAAAVkMQAgAAqyEIAQCA1RCEAADAaghCAABgNQQhAACwGoIQAABYDUEIAACshiAEAABWQxACAACrIQgBAIDVEIQAAMBqCEIAAGA1BCEAALAaghAAAFgNQQgAAKyGIAQAAFZDEAIAAKtpKgirq6s3bNgwefLk1atXl5aW1tdMoVCsX7/+999/11AZAAAADdNUEM6bN+/27dszZsx49eqVv79/fc127969ffv248ePa6gMAACAhvE1MdOMjIyTJ0+mp6d36NDB19fXysrq2bNn7u7uKs3S0tJ27dq1ePHi27dva6IMAACAN9LIFmFERISLi0uHDh0IISKRqF+/fmFhYSptKIqaP3/+xo0bDQwMNFEDAABAY2hkizA3N9fc3Jy5a2FhkZ2drdJm3759lpaWY8eO3b59e8Nzi4+Pj46Ovnr1Kn1XKBT++OOPjo6OzSyysrJSKpVKJBI1+kpl0uqamoqKimbW0IbI5XKxWKxQKFq7EHaprKzkcDitXQXrYLVrX1VVlVQq5fF4LT5nkUjE578h6TQShLq6umKxmLlbU1Ojr6+v3CArK2vz5s0PHz5szNzs7OzMzc2nTJlC3+Vyuba2ts3fjtTX1xcIBDo6Omr0FfAFuiIRq7Zl5XK5QCDQ09Nr7ULYhaIoVr3N3hJY7drH5XKFQqEmgrAxNBKE9vb26enpFEXRv6rS0tImT56s3CA0NDQ9Pd3V1ZUQIhaLpVKpra1tVlZWnXPT19e3t7f38fFhppSXl2uibAAAYCGNHCMcMmQIISQkJIQQEhkZmZCQMGbMGEJIfHz8xYsXCSHjx4/PyclJSkpKSkpau3btoEGDYmNjNVEJAABAwzSyRSgQCLZv3z5jxgxPT8+nT59u2bLFxMSEEHLz5s09e/aMHTtWR0eH2Sepq6srEAjoBgAAAFqmkSAkhEyaNMnb2zs2NrZLly42Njb0xFmzZk2cOFGl5axZsyZNmqShMgAAABqmqSAkhFhYWHh5eSlP0dPTqz3awtjY2NjYWHNlAAAANADXGgUAAFZDEAIAAKshCAEAgNUQhAAAwGoIQgAAYDUEIQAAsBqCEAAAWA1BCAAArIYgBAAAVkMQAgAAqyEIAQCA1RCEAADAaghCAABgNQQhAACwGoIQAABYDUEIAACshiAEAABWQxACAACrIQgBAIDVEIQAAMBqCEIAAGA1BCEAALAaghAAAFgNQQgAAKyGIAQAAFZDEAIAAKshCAEAgNUQhAAAwGoIQgAAYDUEIQAAsBqCEAAAWA1BCAAArIYgBAAAVkMQAgAAqyEIAQCA1RCEAADAaghCAABgNQQhAACwGoIQAABYDUEIAACshiAEAABWqzsIDxw4UFxcrOVSAAAAtK/uIFy5cqWtre2sWbP++usvLRcEAACgTXUH4ZMnTwIDA+/evTtkyJCuXbtu3ry5sLBQy5UBAABoQd1BaGdn9/XXXycnJ1+/fr1Xr16rV6+2s7ObPHnyjRs3tFwfAACARjU0WIbL5fr4+Jw4cSIxMXHu3LknT5709fV99913Dx48KJVKtVYiAACA5rx51Oi9e/dWrVq1f/9+PT292bNn29jYzJkzx9vbWyKRaKE+AAAAjao3CAsLC3/66adu3boNGzYsIiJi06ZNmZmZ+/fvDwkJefDgwePHj69du6bNQgEAADSBX+fUzz777NChQ3K5/MMPP9yxY4e3tzeHw2EeHTRoUOfOnXNzc7VVJAAAgKbUHYRPnz5duXLlp59+amNjU2eDAwcOODo6NjzrEydOnDt3ztDQMCAg4J133lF5NCYm5vDhw6mpqfr6+qNHj/b391ejegAAgGaqOwivX79uaGjI5//jUZlMVl5ebmpqSggZOHBgw/M9cuTI8uXLt23blpiYOHTo0NjY2A4dOig3SEpKMjIy8vf3LygoWLRoUXZ29hdffNG85wIAANBkdQdht27dTp8+PWjQIOWJ4eHhgwYNoiiqMfPdunXrpk2bpkyZQgh5/Pjx/v37V6xYodxg/Pjx48ePp2+Xl5dfunQJQQgAANrXhGuNymQylW3E+ojF4qioKC8vL/qul5dXWFhYfY2zsrJCQkKYxgAAANr0j2Crqamprq4mhCgUivLycuXLjcpksgsXLtjZ2TVmprm5uRRFmZub03ctLCxycnJqN/vrr7+GDBlCCBk5cuTSpUvrm1t8fHx0dPTVq1fpu0Kh8Mcff3zjEco3qqyslEql6p0EIpVJq2tqKioqmllDGyKXy8VisUKhaO1C2KWyslJ5nBpoB1a79lVVVUmlUh6P1+JzFolEb9yE+8fDu3btWrZsGX3bz8+vduvvvvuuMQvW1dUlhIjFYgMDA0JITU2Nnp5e7WaDBw+mKCovL2/+/Pmffvrp4cOH65ybnZ2dmZkZvZeVEMLlcq2treucYZPo6uryBXyBQKBGXz6PLxQKm19DGyKXy3k8Hque8ttALpdjnWsfVnurEAqFmghCLvfNOz7/EYRDhgzZtGkTIeT777+fMWNGx44dmYesrKx69OjRt2/fxizY3NxcJBKlpaXRG4VpaWn29vb1NbayslqyZMnEiRPra6Cvr29vb+/r68tMKS8vb8xzaxiXy+UQjnq/+zgcDpfDaX4NbQhFUVwul1VP+W2Add4qsNq1j/u3Vln6P4Kwb9++dNRJpVKVIGwSLpfr7+8fFBTk4eFRVVV16tSprVu3EkIqKytPnz49ceJEXV3drKwsW1tbuv2VK1e6du3avCcCAACgjrr3nK5evbqZ8w0MDBw5cmRUVFRGRkbv3r3ff/99Qkh+fv7MmTN9fHx0dXUXLVr0/PlzR0fH1NRUHo936tSpZi4RAABADf8/CCMiIk6dOuXn5zds2LANGzaUl5fX2WHjxo2Nma+Li0t8fPyTJ09MTEy6d+9OT3RwcMjIyKBPKPzzzz9fvXqVnZ1tZWXl5uamiV3DAAAAb/T/g/DVq1e7du2ysrIaNmzYwYMH8/Ly6uzQyCAkhAiFwsGDBytP4fF4yuNO3dzc3Nzcml4zAABAi/n/QTht2rRp06bRt+Pj41upHgAAAK3CyCgAAGC1uoMwOjo6KiqKvi2VSjdt2jRhwoQNGzbg/3gBAKCdqTsIJ06ceP36dfr2+vXrV6xYER8fv27dOlwOFAAA2pk6grCqqiohIWH48OGEEIqifvvtt/nz58fExPzxxx8HDx6sbzQpAABAW1RHEJaUlBBCLC0tCSHR0dHZ2dmffPIJIWTUqFESiSQ1NVW7FQIAAGhQHUFobm7O5XLpwPvzzz/19fX79etHCKGvx93Iv2ECAABoE+q4soxQKBw+fPiiRYtmzJixe/fu8ePHC4VCQkhMTAyHw3FwcNB6kQAAAJpS92CZ3377zdDQcO3atV26dNm8eTM98dChQz169KD/oR4AAKB9qPtao87Ozn/99ZfKxK1bt+KK7AAA0M406h/naUZGRpqrAwAAoFXUG4Th4eHnzp1LT0+vqalRnn7ixAnNVwUAAKAldQfhhg0bVq9eraen5+TkJBKJtFwTAACA1tQRhBRFbdq0aerUqb/99pu+vr72awIAANCaOga/5OXllZeXL1myBCkIAADtXt0n1JuZmRUWFmq/GgAAAC2rIwj5fP66desCAwOLioq0XxAAAIA21T1Y5tmzZykpKc7Ozn379jUxMVF+CKNGAQCgPak7CNPS0uhLqRUVFWG7EAAA2rG6g/DatWtargMAAKBV4JJpAADAavVeWSYuLm7Hjh2xsbESieT+/fuEkOPHjxsYGLz//vtaLA8AAECz6t4ivHv3roeHx9mzZyUSSUpKCj0xKytr8eLFWqwNAABA4+oOwoULF/r4+CQkJKxbt46Z6Ofnl5SUlJ2dra3aAAAANK6OICwsLIyJiVm1apVIJOJwOMx0ehwpghAAANqTOoJQJpMRQuh/pVeWn59f53QAAIC2q44gtLKysrW1PX36NCFEeYvw4MGDxsbGrq6u2qsOAABAw+oYNcrhcL755pulS5dWVlZ27NhRJpM9ePDg+PHju3btCgwMFAgE2q8SAABAQ+o+fWLRokVlZWXr16+vrq4mhAwdOpTP5y9evHjFihXaLQ8AAECz6j2PcNWqVQsWLAgNDc3KyjIxMRkyZIitra02KwMAANCCeoOQEGJmZjZ27FitldKGVBblXXv5LKe4XI2+XA4Z7zvcysqqxasCAAA11BGEMpns3Llzd+7cyczMVCgU1tbWQ4cO9ff3F4lE2q/v7VRZnJ9RZUAJu6nRtyTu0YC8PAQhAMBbQjUIk5OTx40bFxsbqzxxz549K1asOHv2rIeHhxZre6sJDU0sO7+jRkdxxssWLwYAANT2j9MnJBLJBx98kJKSsn79+vj4eLlcrlAoUlJSfv7554qKinHjxhUXF7dWoQAAAJrwjyA8c+bMixcvzpw5s3Llyi5dunC5XA6H4+TkFBAQcOvWrYKCgv3797dWoQAAAJrwjyC8cuXK4MGD33vvvdrtevfu/dFHH12+fFlbhQEAAGjDP4IwNjZ2yJAh9TUdMmSIyrFDAACAtu4fQVhSUmJhYVFfU0tLSxwjBACAdkZ1sAyPx6uvKZ/PF4vFmi8JAABAe1RPn4iKijp58mSdTR8/fqz5egAAALRKNQiDgoKCgoJapRQAAADt+0cQHj58uKamprVKAQAA0L5/BGEDQ0YBAADapTr+mBcAAIA9EIQAAMBqCEIAAGA1BCEAALAaghAAAFgNQQgAAKxWxz/Ut5Tw8PA9e/ZIpdJPPvlk1KhRKo/m5eWdPHkyPDycx+P5+vpOnjyZy0UqAwCAtmkqe169ejVy5MiePXuOGDHi448/vnnzpkqDo0ePPnz40MvLa+DAgcuXL//uu+80VAkAAEADNLVFuGPHjqlTpy5evJgQkpeXt23btpEjRyo3WLx4MYfDoW8bGhquWbMmMDBQQ8UAAADUR1NbhGFhYUOHDqVvDxs2LCwsTKUBk4KEkKysLCsrKw1VAgAA0ABNbRHm5OSYm5vTty0sLIqKisRisVAorN0yNTX1+++/P3HiRH2zio+Pj46Ovnr1Kn1XKBT++OOPjo6OzaywsrJSKpVKJBI1+srkMoWco15fqVRaVVVVUVGhRt9WJJfLxWKxQqFo7ULYpbKyUvknI2gHVrv2VVVVSaXSBv4HUG0ikYjPf0PSaSoIdXV1mT8vrKmp4fP5AoGgdrPs7OxRo0atWbNGZcepMjs7OzMzsylTptB3uVyutbW1np5e8yvkC+qu6o14XB6X4qjXl8/ni0Si5tevZXK5nMfjtbmy2zq5XI51rn1Y7a1CKBRqIggbMwxTU0Ho4OCQnp5O305LS7Ozs6tdTV5e3siRI2fPnr1kyZIGZqWvr29vb+/r68tMKS8vb/4QUy6XyyEc9X73cTgcwiFq9+VyuW1uiCxFUW2x7LYO67xVYLVrH/dvrbN0Dc3X39//6NGjMpmMEBIcHDxx4kR6+pkzZ+iALCgo8PHxmTJlyooVKzRUAwAAwBtpKghnzZolEonc3d0HDhwYHR3973//m54eEBBAD5z5+eefY2JigoODnZ2dnZ2du3fvrqFKAAAAGqDBY4S3b99+9uyZRCLp06cPc6wyPDzc2NiYELJ06dLZs2cz7XFoGgAAWoUGryzD4XA8PDxUJlpbW9M3zMzMzMzMNLd0AACAxsABYQAAYDUEIQAAsBqCEAAAWA1BCAAArIYgBAAAVkMQAgAAqyEIAQCA1RCEAADAaghCAABgNQ1eWQbqpJDLysrKiouL1egrEAgMDAxavCQAADZDEGpbdsyTM7GXQ60s1ehbIef8+9vvkIUAAC0IQahtHIV0uKvNEI9eavTdc/uJXC5v8ZIAANgMxwgBAIDVEIQAAMBqCEIAAGA1BCEAALAaghAAAFgNQQgAAKyGIAQAAFZDEAIAAKshCAEAgNVwZRn1UAqZTCauVqOnQi5r8WoAAEBtCEJ1lGanS+Mfvcp5oUbf4phH5fb9W7wkAABQD3uDsLS0NOWvK8UZaer0jb7nbq774fABavTdm/xMoVCo0REAADSBvUFYXV1tRsQfdLdXo+/FRAGlwB5OAID2gL1BSAjhcbkGevpqdOTzeITCv0AAALQHGDUKAACshiAEAABWQxACAACrIQgBAIDVEIQAAMBqCEIAAGA1Vp8+0eaUV1alpqYaGhqq0VdPT8/a2rrFSwIAaOsQhG3Jq5exdw7/pisSNbWjQqGoEBr9e+1/NFEVAECbhiBsSziEet+9q6WpSVM7lldVH4tO1UBFAABtHo4RAgAAqyEIAQCA1bBrlBUUFJWekfngwQP1utvb2zs4OLRsSQAAbwkEIStU1Yhzk+OLQq+q0bewtDyzq7vDtOktXhUAwNsAQcgWOlzusJ6uanSMS8tU5z8bAQDaCBwjBAAAVkMQAgAAqyEIAQCA1RCEAADAaghCAABgNQQhAACwGoIQAABYDUEIAACshhPqtU0qrsnIzo2IjlGjb0lJqVwub/GSAADYTINBeOfOnaCgIC6XO3fu3EGDBqk8KpFIQkNDIyIi8vPzAwMDRU3/j702SiaTFSmEuXxLNfpW1EjlMlmLlwQAwGaaCsJHjx598MEHW7dulclko0ePvnfv3rvvvqvcICEhYcmSJW5ubidOnFixYgV7gpAQwhfq6pmqE4SE09KlAACwnqaCcNu2bQEBAfPmzSOEJCYmbt++fd++fcoNunfvHhkZmZWVdeLECQ3VAAAA8EaaGiwTFhY2bNgw+vawYcPCwsI0tCAAAIDm0NQWYW5urrm5OX3bwsIiOztb7VklJCRERUVdvfq/vxDS0dHZtm2bo6NjMyusqqqSKxTqjT2hKIpQRM2+hKIUlJpjXigilcokEklT+0kkEoVCoUZHQohUKq0RiysqKsRisUKhUGMOoLbKykoOBzvEtQ2rXfuqqqqkUimPx2vxOYtEIj7/DUmnqSAUiURisZi+XVNTo6enp/asbGxsTE1Np0yZQt/lcrnW1tbNmSFTIZfL4XHV2SamPyRq9iUcou5yCYfw+TyBQNDUfgKBgMvlqtGREMLn83V0dPT09Hg8XvNXOzSJXC7HOtc+rPZWIRQKNRGE3EZ82WoqCO3t7dPT0wcMGEAISUtLs7e3V3tWBgYGDg4Ovr6+zJTy8vLGPLeGcblcDuGQ5vzuU7cvpzl9ORw1fqvSXdT7kcvhcLgcDvdvaswB1IZ13iqw2rWvdb9hNLXUiRMnBgcHUxSlUCgOHz7s7+9PTz969GheXp6GFgoAANBUmtoiDAgIGDFiRP/+/WUymUAgmD9/Pj191qxZN2/etLKyksvlrq6u9KGy3r176+npxcSoc445AABAc2gqCM3MzCIiIp48ecLlcj09PZkN3pSUFEtLS0IIj8e7fv060x6HpgEAoFVo8MoyPB6vf//+KhOVDxZ27txZc0sHAABoDBwQBgAAVkMQAgAAqyEIAQCA1RCEAADAaghCAABgNQQhAACwGoIQAABYTYPnEQLk5+enp6er15fD4fTq1euNl40HAGgmfMuABj15HJZ894qlqbEafRMLyjp0WGFnZ9fiVQEAKEMQgiZRxM3Gom9XFzW65v0V2eLlAADUhiCEN8jMLzx38U50+CO5XN7UHZUp6a/Hd3fSTF0AAC0DQQhvIJbJXM30FvsNpP9IpEl9tx0vkMnlGioMAKBFYNQoAACwGoIQAABYDUEIAACshiAEAABWQxACAACrIQgBAIDVcPpEW6KQy4uKinR4Tf75UlhcKpFKNVESAEBbhyBsS8QSydO0IpNSRVM7FpaWFpWUaaIkAIC2DkHYxujbOBl3sG1qL0leLiG3NVEPAEBbh2OEAADAaghCAABgNewahbdUQnLaqeADRsZGavTVy5c+BgAAHjpJREFUMzSZMmNmi5cEAO0SghDeUmUlRc5UmYOublM7KhTUmYgwgiAEgMZBEMLby9rMxMnaqqm9FBRFnqdooh4AaJdwjBAAAFgNQQgAAKyGIAQAAFZDEAIAAKshCAEAgNUQhAAAwGoIQgAAYDUEIQAAsBqCEAAAWA1BCAAArIZLrEE79Doz83rIFfX62tjZ9+jZs2XrAYC3GYIQ2hsFRRW8Tle8CFWjb0llVbqZA4IQgFUQhNAecciA7q5q9HudVxBW1uLVAMBbDccIAQCA1RCEAADAaghCAABgNRwjZAWKUkgkkoSkZDX6ZmfnVFdXt3hJAABvCQQhK8hlUolMHlvGU6NvSqlUXlHZ4iW9neRyRVZOfkxMjHrd7e3tjY2NW7YkANA0BCFrcDjG1o5q9BPEJ1Tm1WRnZ8vlcj6/aW+YsopyucxEjYW2lryS0uRnj5/qqnPIoLC0tOd7E0b6+LR4VQCgUQhCeANZdVVJteRJRhmloLjcpiVEel6pi0Vb2kKiCDHVFY737KZG30cx8RSlaPGSAEDTEITwZhyejpG9q0Kh4PKatnOVo/NQQyUBALQUjBoFAABWa5NbhFevXvX39+dwOK1dCItIJJLqmpqmjwShKAUlk8nUWCJFUWr0aqPi4+PT09NrT3/06JG7u7tQKGygr1AoHDx4cFP3WkN9qqqq7t69O3bs2NYuhF2ePn3aqVMnOzu7Vlm6poJQLpfv3bv33r17Dg4Oy5Yt69ChQ+02d+/eDQoK4nK5c+fOHThwYONnPm/evJEjR5qamrZcvfAGxSUlRYWFTQ1CSVVlYobsyr1HaizxdRaLTtsIf3CXkxpjbmSoMj37+gWnigxLC8sG+t7KKPT09NTT09NkgSzy4sWLwMBABKGW7dixY8yYMTNmzGiVpWsqCAMDAy9cuLBmzZqrV696e3tHR0erDDh89OjR+PHjt27dKpVK/fz87t279+6772qoGGgBam2fKYiCo29u2G2wOgu8EapQtKWxJxRFVVRUFBcXq9G3urq6t4NtF3sblenPQ408XJwa/pn88HVoSUmJWCxWY7m6uroikUiNjs0hk8nKy8vV68vn8w0NVX8uQPvQijuBNBKE1dXVO3bsuHr1at++fT/66CNXV9dLly598MEHym1++umngICAefPmEUKSkpK2b9++b98+TRQDbVRNTc3TmFd5hSVN7ahQKLJzcq/dV2cz9FVGTlFJk5f4v77pWa8iYhLD7qvR9+nzF51H9CdENQgbIyoyKujHjQJBkz/LEonkSUp2575eaiyUEDJ6kPvI4cPU6PjTj9tCb4TwmzjwilYlU+zct79jx45q9AWoj0aCMD4+XiKR9OnThxDC4XC8vLwePXqkEoRhYWF0ChJCvLy8Vq1apYlKoO1SUAq5iQPXoWtTO1JymUR2luvQS42Fyso44pQ0NToSQuQKRU8r42nDPNTouyohXu3NXy4lnz6gu5GBflM7ZuUV3IlJ5Q+crsZC81Ne5hQUqtGREFJUUuLu2rV7D3X2AP33t52/bPjOzNxMjb5m1nafByxRoyO0exxNbI1evXp13rx5zMH/r7/+Ojc39+DBg8ptdHV1Q0ND3d3dCSGhoaHjxo0rLKz7czV48ODIyEhmBw6HwykrKxs4cGBTT+5WUVVVJa+ssrGwUKNvfn6ODpdrbG6lRt/Xr1MtzUxF+uqcXZeaEu/o4MTl6zS1o0wizsp67ejkosZCi4sKFdIaY3MrmUwmEuk2qW921mtjAwM9I3WO5qamJtrZ2AmETVsiIYRSKFJS4js7NzlBCSGVlRXVhZkO5uq8Ojkl5bp8nrGBOsfq0vKLOxjpi4Sqr2xxcbGhgQFfIGigb2JOYWcrUzUGy8hksof5Eqltj6Z2JITIqsp0CpIM9NTZrVpdVdXT0UGoZ6BG3/SUBEdjoUCtz/6zrEKOntEbm0kkkry8PHt7e2aKQqEQi8W6uk1+K9JzI4To6DT5M0sIqaqqEgqFPLU2nSsrK/X1m/zbiBCiUChqamrUO+QslUoVCkXDY7vqk5eXZ2Njo7zaW8pHH320cOHChttoZItQV1dX+YhFTU1N7ZdEJBIxbRpe7//5z3/u37/PzIHL5RoaGjo7O7d01dCQqqqq8vLyOgc9geakp6fb2dmp91XYGJ9raL5tmVwuz8zMdHRU5zJMoLbc3FxDQ0NNjPnq1KnTG9toJAjt7OyKiooqKioMDAwIIenp6X379lVpY29vn56ePmDAALpBAz8EfHx8fHDZKgAA0AyNnHvk7Ozco0ePo0ePEkKysrJu3rzp7+9PCMnOzj516hTdxt/f/9ChQxRFKRSKw4cP0w0AAAC0TCPHCAkhd+7cmTRpkqen5/Pnz6dPn75582ZCyJUrV6ZNm0aPLy8qKvL29hYKhTKZTCAQ3LhxA6OiAQBA+zQVhISQkpKSyMhIR0fHzp0701NqamoKCwuZk6LkcvmTJ0+4XK6npyeuiwEAAK1Cg0EIAADw9nsbrzUqFotDQkLKy8t9fX3rG6b48OHDuLg4d3f33r17MxNLS0tDQkI4HI6fn5+R0ZvHSYOy7OzsGzduGBsb+/n51R7tTVHU06dPY2JizMzMRowYwQzuevz4cVlZGX3byMioX79+Wi26jVMoFDdv3szMzPTy8mJ2nCi7f/8+M7jawsKCebfX1NRcvXq14c8I1KfhL4rk5OTk5GTlKcOHD+fz+S9evMjJyaGn8Pn84cOHa6fa9kEqlcbExJSUlDSw3h4/fhwTE9OrVy9PT09mYnl5eUhIiEKh8PPz09y/Xr91W4TV1dVDhgwxMjJydHS8dOnSrVu3evVSPTP6m2++OXHixKhRoy5cuPDNN98sWrSIEJKVldW/f/9+/fopFIrIyMhHjx7hC6Lxnj596uvrO27cuJSUFLFYfOfOHZUrb33yySdPnz7t27dvenp6YmLivXv36C/uPn36UBRlZmZGCHFzc/v1119b5wm0TR9++GF6erqnp+eZM2eCg4PHjBmj0sDBwcHe3p4efT1gwIB169YRQqqqqoYOHcp8Rm7fvt2zZ89WqL5tyszMHDBgQL9+/eRyeVRUVFhYmJXVP04IDg4OPnToENM4Nzc3JydHIBBMmzbt2bNn9Ph2AwODM2fOtEL1bdPdu3f9/PwMDAwkEklpaWmdbf7zn//s379/9OjRly5dCggI+OqrrwgheXl5AwYM6Nmzp0AgCAsLe/jwoSZONCSEEOot8/vvv/ft21cmk1EUtWrVqkmTJqk0yMrKEolEqampFEWFhYWZmJhUVlZSFLV8+fJp06bRbSZNmrR69WrtFt62ffDBB4GBgRRFyWQyd3f34OBglQaJiYnM7QkTJnzxxRf0bU9Pz2vXrmmtzvbk3r17NjY25eXlFEUdPHiwd+/etdvY29tHRUWpTNy7dy/9PU5R1IoVKyZPnqyFatuNr776ivmimDhx4po1axpoPG3atEWLFtG3p06d+uuvv2q8vvaopKQkPz8/LCzMyMiozgYFBQW6urqvXr2iKCo6OtrAwKC0tJSiqLVr106YMIFuM2PGjC+//FJDFb51Q1QuXrw4YcIE+gziiRMnXrx4UaXB1atX3333Xfpig/369TM0NHzw4AEh5MKFC8w5GP7+/rU7Qn0UCsXly5fptcfj8T788MPaa0/5CgY2Njb09TJosbGx165dy8jI0E617cbFixfpn8mEEH9//6ioqNevX9duFhkZef369dzcXOWOEyZMoMeX1fkZgQZcvHhx4sSJ9O2GvyhKS0vPnj07Z84cZkpqauqVK1eSkpI0XmX7YmxsbNHgNbxu3Ljh6urq6ur6/9o786AojnCBN4fLvbss6y6w4FKslIAgooIgcivxSAFyiAcCJgSMsbSiaHngFUEqGoVKRCkNKhiDBA8OkfsQCYhouFFAUZFTlns595j3R79MzVsQV5+okf79Nf1NX9PT09/09Df9AQCMjY01NTXz8/MBALdv3/44o/pnpwhbWlpws1IWizU8PNzd3S0WgTg7ZrFYLS0t4xNCIUISOjs7+Xw+3qqTt15jY2NcXNzmzZthUFlZOTU19ZdffjEwMDhy5MhHqO0XA7EnKysrk8nk8c1OpVLj4uLCwsI4HE5kZCSekNjVh4aG3s/lxfRE8oHijz/+0NfXx9dlSSTSgwcPzpw5s2jRIj8/P+wzW1T6T9Pc3PxpR/XPzlhGKBTiv1LAeaGYW1ehUEh0ySsrKwsjEOUyMjLv5wx2eiIUCgEAkrReZ2ens7Pznj174JZAAICcnBx4m6qrq83NzV1cXOD+sYi38qaeTKS8vBw2771795YtW+bs7Kytrf3WZwQxCZIPFBcvXvz222/xYHR0NGztjo4OU1PT69eve3p6TnVtpwmTjOrErj51/fyzmxFqaGi8fv0aHnd0dMyYMUNsTk2MAONoampCeWdnp5gQIQkMBkNaWvqtrdfT0+Pk5OTi4rJ3715ciG+DaWRkZGRkVF5e/hEq/GVA7MljY2M9PT3jmx1vXmtrayaTWVVVBcY9IyQSafLvTggiEg4UVVVVtbW169evxyX4vWAymfb29mVlZVNd1enDJKM6satP3aj+2SlCOzu7zMxMeJyZmWlrawvfCPr6+qAdua2tbWlpaW9vLwCgsbGxubkZzk7s7e2JCZFxs+TIysouXbo0IyMDBvHWE4lEXV1d8BNQX1/fihUr7OzsQkNDJ8ykt7f32bNnaKtiybGzs8vOzobT8aysLDabraOjAwDg8XhDQ0NikaH5ora2NpjoGSG+TSMmx87ObnxXBwB0d3cTJxwXLlxwc3NTVZ3AcYpAIKisrIT3AvH/ob+/f2RkBABgY2NTUVEBX1BaWlrq6+utrKzAuK4+haP6FBnhvDdw65nAwMDjx49TqdScnBwonzdvXlRUFDz28vKysrKKiIiYN2/ezp07obC2tpZCoRw4cGDv3r1UKrW+vv7TXMB/k/T0dFVV1bCwMH9//1mzZvX09GAY9uLFC9gvMQzz9PQkk8kB/xIeHo5h2OPHj1esWHH06NGQkBADA4Ply5dDU0aEJEAD3TVr1pw6dYrFYl24cAHK3d3dYa++d++eq6trSEjI4cOHdXR0cFtHLperqamJPyO5ubmf7Br+g9TU1Ew4UJBIpLy8PHg8OjpKp9PxwQfDMD6fb2lpeejQobCwMCsrK0NDQ2jui5AELpcbEBDg6upKIpECAgJwk35zc3M4kmAY5uvra25uHhERsWDBgq1bt0JhQ0MDlUrds2dPcHAwhUKprq6eohp+dv8RAgDa29tjYmIGBwddXV0XLPhfN6c3b940NDTU19cHAAgEgitXrtTV1S1cuNDDwwN/Ha6vr7927ZqUlNSGDRuQn6Z3pbS0NDk5mUwm+/r6wj+reDxeXFzcxo0bFRUVU1JS2tra8MgsFmv16tUjIyM3b9588uSJtLT0vHnzXF1d0VZ578TAwMClS5c6OjocHBwcHR2hMCcnR1lZefHixf39/bdu3Xr69OmMGTPMzMxWrlyJJ2xra4uNjRV7RhASMuFAAX9i09DQAAB0dHSkpKR88803eH/GMCwpKamiokIgEOjp6Xl5eb2f173pCY/Hgz4YIBQKxcvLCwCQlJQEPTQAAIRC4Z9//llTU2NiYuLl5YW3fGNj49WrVzEMW7duHTQrnQo+R0WIQCAQCMRHA72/IxAIBGJagxQhAoFAIKY1SBEiEAgEYlqDFCECgUAgpjVIESIQCARiWoMUIQKBQCCmNUgRIj5TmpubY2Ji3uS97D9NXl5eWloaPO7r64uJifngvju4XO758+e/gK3nX716df78eS6X+6EyrKqqwt0NIhAQpAgRH5Xc3FwOh8PhcIqKiojykZERY2NjDofz008/QUlZWZmfn98XMJSPJyIiIiQkBB63tLT4+fl98I0rX716FRgYWFtbO+HZqKgoXV3dpqamD1voVFBTUxMYGDihgypIbGzs/fv3Jc8wOTmZ6FkJgQBIESI+MkNDQ42Nja2trRcvXiTKk5KSnj592tjY2NXVBSX6+vrHjh0T8x7+5cFgMI4dOwa3TPpo9Pb2Pn/+nM/nf8xCp4hdu3Zdv35d8vh2dnb4yxYCAUGKEPEJcHV1TUhIIG4tffnyZVdXV+Lm0Xp6esHBweP9KggEAtx7gCT09/cPDg5OeGp0dLS9vR1u+ztJBLgvNgTDsNevXxP9EguFwjd9uOPz+cQ99SeETqcHBwfr6elNHg1nbGysvb19eHh4wrPd3d39/f0SZjU5nZ2dYq5AJWTyGgIAhoeH3+RAcXBwsKOjg9jgRAYGBng8nuQ1GRgYaG9vF4lERKGVldW+ffvGRx4dHX2/60V8ASBFiPgErF27ViAQ3Lx5EwZbWlqysrL8/PyIcbKysjQ0NBoaGmDQyspqy5YtZ86cYTAYDAZDVVX11KlTb8r/9u3bNBotLy9v2bJlFAqFTCZbWlq+fPkSj9DX1+fj40OlUjU0NKhUqre3Nz40j42N0Wi08PDwH374AUaorKzcsWPHwoUL09LSdHR0mEwmlUo9efIkAODkyZNqamozZ85ksVi5ubl4/vHx8fPnz5eTk2MymcrKym5ubkQX80QaGho0NDSysrIAAHl5ebRx+Pj4wJj9/f3fffcdjUbT0NAgk8lr1qwhatlnz54tXbpUTU2NQqHY2dkRL/Zd+f3339lsNoPBUFNTMzQ0zMnJgfIff/xx9uzZYvNIOzs7Z2dneDwwMBAYGIjX0MXFBb/q9vZ2Go126dIlf39/CoVCo9E4HA70Qg5JTU2dM2eOsrKyurq6vLw8vvMqnnzlypXwVi5atAjvFWpqal1dXZGRkbCtcA139+5dMzMzMpmsoaGhoaGB+zQGAPz666+4jxShUAjv9c6dO6lUqpqampaWVlJS0ns3HeK/yhRt5o1ATEhKSgoAIDs729vbe9myZVB4/PhxFoslEAikpKS2b98OhcnJyQCAmpoaGDQyMlJXV7ewsEhLSysuLoabrZeXl09Yyo0bNwAAbDY7NDS0pKTk6tWrVCrVxcUFnhWJRPb29goKCmfPnq2srIyKilJUVLS2thaJRBiGQW9fDAZj9erVaWlpOTk5HR0d/v7+ZDJZX18/ISGhpKRk06ZNAAB/f39bW9usrKyCggIzMzMGgzE0NASLiIiIiIiIKCoqevz48ZUrV9TV1R0cHPDqOTs7L1myBB7X1NQAAJKTkzEM43K5WQTCwsIAAEFBQRiG8fn8pUuXqqurX758uaamJjExUUdHx8zMDLr7GBoa0tPTY7FYiYmJVVVVBw8enDlzJgAgMzNzwvaBOT99+nT8qfDwcCkpqd27dz98+LCkpMTNzU1OTq6qqgrDsLt37wIAkpKS8Miw8tHR0RiGCQQCGxsbJpN56dKlmpqapKQkXV3dBQsWCAQCDMPgWq+6urq/v39hYWFGRoaBgcGsWbNGR0cxDGtvb1dQUNi4ceM///xTV1eXnZ29a9cuWAS0KtLW1j5y5EhJSUl8fDydTl++fDk8m5WVRaFQPDw8YIs9efIEw7DCwkISieTs7Hz37t2Kiorg4GApKamLFy/CJCEhIbKysvAY+l1SV1f39PTMz8/Pz883NzenUqnQ+wpi+oAUIeKjgivCrKwsaWnply9fYhimr6+/b98+DMMmV4Q0Gq27uxsG+/v75eXljx49OmEpUBEeOnQIlxw8eFBGRmZsbAzDsIKCAgAA7v8Fw7AzZ87gagMqQj09PT6fj0fw9/cHADx48AAGeTyevLw8nU7v6+uDEqgksrOzJ6xPXFwcAKC1tRUG36QIiTQ3N2tpadnY2IyMjGAYFh8fDwDA/QRhGFZYWIiXGBsbK1b6hg0b3kMRDgwMkMnkwMBAXDI6Oqqrq+vv749hmEgk4nA4bm5u+Nndu3crKSn19/djGAYX6oh1gDYsGRkZ2L+K0MnJCT+bmpoKACgqKsIwDE46J3SyAxUhfBsgVh73gkSn03GtCbG2tp4/fz7x9q1bt87Q0BAej1eEpqamuPuwhw8fAgBu3bo1YbshvlRkp3K2iUC8EQcHBy0trdjYWAcHhydPnuAfACfBwsICd5SqoqKira09iTEhAIDot8jQ0FAoFLa2trLZ7PLycgAAdAQD8fLy2rZtW0FBwfLly6HExcVFVvb/PB00Gs3MzAweKykpsVgsQ0NDMpkMJdBBDLE+5eXld+7caWtrGxsbgxZAz549g15+3srAwMCqVauUlZUTExOhu5/MzExFRUU+n5+dnQ3jiEQiWVnZ6upqR0fHsrIyKpVK/Jzo7u5OdHwjIcXFxf39/dra2ngpAAAdHZ3q6moAgJSUlI+PT2hoKJfLpdPpIpEoLi7O3d1dRUUF1lBeXl4kEuFpMQwjkUjV1dVOTk5QQrwjBgYGsMUsLS319fUVFBR8fHwCAwO//vrr8Y7IxW4lTAhzEIPH4xUVFa1du5b43ZXBYNTV1Y2NjZFIpPFJvvrqK9zpD14rCVsM8WWAFCHi0yAtLe3j4xMTE/Py5Us4FL41CY1GIwbl5OSIRivjIboXhyMgjN/U1CQtLc1kMvGzdDqdRCLhBqsAAOLZ8bnBDMfnD2eTAICgoKDw8HAbGxsDAwNVVVU485Dwn0iBQODh4dHa2lpcXIwX0dHRMTo6SlTeAAAVFRW4tNnS0iJW4fG6RBLgkt6JEydkZGSIctwbu6+v79GjR69du7Zt27aMjIzm5mZfX188LZ/PF6uhkpJSb28vHiS2GFTwsMU0NTVTUlIOHjz4/fffBwYGmpqaHj582MXFZcKExFs5Hi6XKxQKk5KS0tPTiXIymQwdGo9P8qZaIaYPSBEiPhm+vr6hoaEvXryAXyY/GkpKSiKRqLu7GzdJ7evrGxsbo1AoeByi/eq70tPTc/r06ZCQkP3790NJdna22O8ik7B9+/aCgoLc3NzZs2fjQgqFQqVSOzs7J6wYk8kUs1x9q7XqhMAWSEhIwOdwYrDZbDs7u5iYmG3btsXExMAgnlZFRaWrq+v9ms7R0dHR0ZHL5ebn54eHh7u7uz969MjExORd84Fz9KCgoKNHj75HNRDTE2Q1ivhkzJ49OyAgwN7eXmwaMdUsXrwYAADXqCBw5dLS0vKD5A8XPhcuXIhL7ty5I2Han3/+OSoqKjo6Wqwytra2XV1dRMNUIkZGRl1dXXB9CyI2H5IQCwsLEomUkJAwSRxfX9+HDx/+/fffycnJvr6++EdFW1vb3t7ezMzM9ygXh06ne3h4XL16VSgUlpaWSpJEWVmZ+KsGjUYzNja+desWnIUjEJKAFCHiUxIVFZWZmUmlUj9moU5OTiYmJnv27ElPTx8YGMjIyAgKCjIyMlq1atUHyZ/D4SgrK4eHh7e1tfX19UVGRsbExEiSMD09ff/+/Vu2bLGwsGj8F/i50tvbe+7cuZs2bfrrr7+6urp6e3sfPHiwa9euuro6AICXl5e6uvrmzZsrKip4PF50dPS1a9feWlxqamo8gcTExJkzZwYFBUVHR+/fv//58+fDw8P19fWRkZHR0dF4Krgo6O3tPTIyQlzZ3bhxo7GxsZ+fX3x8PKxhaWlpUFDQm3a3IZKZmRkaGlpbWzs6OtrT03PhwgUpKSlTU1NJGm3u3LlpaWl37tx59OgRXNsLCwurrq5eu3ZtZWXl8PBwU1NTQkLCgQMHJMkNMT1BihAx7ZCRkbl9+7aBgcHKlSvJZPKKFSv09PRSU1PFrGPeGxUVlejo6Pv372tqalKp1N9++434H9sklJWViUSic+fOcQhs3boVAKCgoJCTk2NhYbF+/Xo6na6qqmppaVlcXKyoqAgAoFAoycnJPB5v/vz5KioqoaGhp0+ffmtxO3bsWEcAWsYeO3YsJCTk7Nmzurq6ioqKc+bMOXHiBCwFoqSk5Onp+eLFC2traw6Hg8vl5OSys7OXLFmyYcMGWEMLC4vCwkJi2jchLS0dGRk5d+5ceXl5Go12/vz5c+fOEafUk3DixIlZs2Z5eXktWrQI/lq6evXqGzdulJWVmZiYKCoqstnsgIAADMMkyQ0xPZFC/QPx2SIUCsWsNj4sTU1N7e3tTCaTzWZ/8MwHBwfr6+sVFBTmzJkjtmwG9zrBPyq+02X29PQ0NDQoKChoa2uLzaSFQmFlZaWsrKyhoeHkGWIYJrbfCgBASkoKrxKfz3/8+PHIyAiLxdLU1HynZb/e3l544VpaWmIWRpPz6tWrtrY2Mpmsq6s7oXnnO4FhWENDQ29vr5qaGpvNxt9yoLk8fqUIBECKEIFAIBDTHPRahEAgEIhpDVKECAQCgZjWIEWIQCAQiGkNUoQIBAKBmNYgRYhAIBCIaQ1ShAgEAoGY1vwPr7x6kqpQH24AAAAASUVORK5CYII=", + "image/png": "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", "image/svg+xml": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ], "text/html": [ - "" + "" ] }, "metadata": {}, @@ -913,20 +3071,20 @@ "source": [ "# Sampling and Levenshtein plot\n", "using Random\n", - "n = 500\n", + "n = 1000\n", "# 100 model samples (final states → strings)\n", "model_samples_any = sample_gen_n(P, model; n=n, ts=0f0:0.01f0:1f0, rng=Random.MersenneTwister(42))\n", "model_final_states = map(final_state_from_gen, model_samples_any)\n", "model_strings = [state_to_PM_string(P, s) for s in model_final_states]\n", "\n", "# Build training strings from PM parents (the data PM was built on)\n", - "train_states = [FF.DiscreteState(P.k, sample(PM; rng=Random.MersenneTwister(1000+i))) for i in 1:n]\n", + "train_states = [FF.DiscreteState(P.k, sample(PM; rng=Random.MersenneTwister(1000+i))) for i in 1:100]\n", "train_strings = [state_to_PM_string(P, s) for s in train_states]\n", "\n", "# Independent validation strings sampled from PM\n", "val_states = [FF.DiscreteState(P.k, sample(PM; rng=Random.MersenneTwister(1000+i+2*n))) for i in 1:n]\n", "val_strings = [state_to_PM_string(P, s) for s in val_states]\n", - "val_strings = [s for s in val_strings if !(s in train_strings)]\n", + "#val_strings = [s for s in val_strings if !(s in train_strings)]\n", "\n", "# Plot normalized Levenshtein vs. training set (distinct val/train)\n", "plt = plot_lev_dist(\"model_vs_true\", val_strings, model_strings, train_strings; title=\"Model vs True (normalized Levenshtein)\")\n", @@ -935,192 +3093,410 @@ }, { "cell_type": "code", - "execution_count": 75, + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model_strings_bos = [\">\" * state_to_PM_string(P, s) for s in model_final_states]\n", + "plt = plot_lev_dist(\"model_vs_true\", val_strings, model_strings_bos, train_strings; title=\"Model vs True (normalized Levenshtein)\")\n", + "display(plt)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "image/svg+xml": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ], "text/html": [ - "" + "" ] }, "metadata": {}, @@ -1128,187 +3504,187 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "image/svg+xml": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ], "text/html": [ - "" + "" ] }, "metadata": {}, @@ -1326,14 +3702,14 @@ }, { "cell_type": "code", - "execution_count": 64, + "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Natural 'A' frequency: 0.04931058658565085\n" + "Natural 'A' frequency: 0.047142480905978404\n" ] } ], @@ -1343,14 +3719,14 @@ }, { "cell_type": "code", - "execution_count": 66, + "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Natural 'A' frequency: 0.038456812876274726\n" + "Natural 'A' frequency: 0.04109772423025435\n" ] } ], diff --git a/editflow_code/editflowsrun.jl b/editflow_code/editflowsrun.jl index 93fe021..3ef36e0 100644 --- a/editflow_code/editflowsrun.jl +++ b/editflow_code/editflowsrun.jl @@ -169,7 +169,7 @@ end K = PM.K println("K: ", K) -P = FF.EditFlow(K; bos_token=0) +P = FF.EditFlow(K; bos_token=0, impl=:positionwise) model = EditFlowModel(; d=128, num_heads=8, nlayers=4, rff_dim=128, cond_dim=128, K=K) diff --git a/editflow_code/gapwise_notebook.ipynb b/editflow_code/gapwise_notebook.ipynb index e20058d..4d36385 100644 --- a/editflow_code/gapwise_notebook.ipynb +++ b/editflow_code/gapwise_notebook.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 50, "metadata": {}, "outputs": [ { @@ -13,7 +13,9 @@ "\u001b[32m\u001b[1m Resolving\u001b[22m\u001b[39m package versions...\n", "\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `~/dev/Flowfusion.jl/editflow_code/Project.toml`\n", "\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `~/dev/Flowfusion.jl/editflow_code/Manifest.toml`\n", - "WARNING: using StatsBase.sample in module Main conflicts with an existing identifier.\n" + "WARNING: redefinition of constant Main.AA20. This may fail, cause incorrect answers, or produce other errors.\n", + "WARNING: redefinition of constant Main.TOK2ID_AA. This may fail, cause incorrect answers, or produce other errors.\n", + "WARNING: redefinition of constant Main.PM. This may fail, cause incorrect answers, or produce other errors.\n" ] }, { @@ -22,7 +24,7 @@ "plot_len_dist (generic function with 1 method)" ] }, - "execution_count": 1, + "execution_count": 50, "metadata": {}, "output_type": "execute_result" } @@ -30,7 +32,7 @@ "source": [ "using Pkg\n", "Pkg.activate(@__DIR__)\n", - "#Pkg.instantiate()\n", + "Pkg.instantiate()\n", "using Revise\n", "\n", "using Random\n", @@ -52,7 +54,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -61,7 +63,7 @@ "to_same_device (generic function with 1 method)" ] }, - "execution_count": 2, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -84,7 +86,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -93,7 +95,7 @@ "make_minibatch (generic function with 1 method)" ] }, - "execution_count": 3, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -122,7 +124,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -131,7 +133,7 @@ "gaps_from_sites_avg (generic function with 1 method)" ] }, - "execution_count": 4, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -155,7 +157,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -164,7 +166,7 @@ "EditFlowModel" ] }, - "execution_count": 5, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -192,7 +194,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -234,7 +236,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -243,7 +245,7 @@ "train_editflow! (generic function with 1 method)" ] }, - "execution_count": 7, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -280,13 +282,13 @@ " Z1 = vcat(fill(bos, 1, batch_size), Z1)\n", "\n", " # 2) gap-wise masks & multipliers\n", - " transition_mask = FF.transition_mask_from_Xt_gapwise(P, Xt) # (2K+1, L+1, B)\n", - " edit_multiplier = FF.remaining_edits_gapwise(P, Zt, Z1, Xt) # (2K+1, L+1, B)\n", + " transition_mask = FF.transition_mask_from_Xt(P, Xt) # (2K+1, L+1, B)\n", + " edit_multiplier = FF.remaining_edits(P, Zt, Z1, Xt) # (2K+1, L+1, B)\n", " @assert size(transition_mask) == size(edit_multiplier)\n", " @assert size(transition_mask, 2) == size(Xt, 1) + 1\n", "\n", " # scheduler\n", - " den = 1f0 .- P.κ.(ts); den = max.(den, 1f-2)\n", + " den = 1f0 .- P.κ.(ts); den = max.(den, 1f-3)\n", " scheduler_scaling = P.dκ.(ts) ./ den # length B\n", "\n", " # 3) masked state → device\n", @@ -305,7 +307,7 @@ " M = m(ts_d, Xt_ms_d) # (2K+1, L+1, B)\n", " # shape sanity\n", " @assert size(M) == size(Tmask_d) == size(Emult_d)\n", - " FF.edit_loss_gapwise(P, M, Tmask_d, Emult_d, sched_d; eps=1f-8)\n", + " FF.edit_loss(P, M, Tmask_d, Emult_d, sched_d; eps=1f-8)\n", " end\n", " Flux.update!(opt_state, model, grad[1])\n", "\n", @@ -321,7 +323,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -330,158 +332,6 @@ "text": [ "K: 20\n" ] - }, - { - "data": { - "text/plain": [ - "EditFlowModel(\n", - " Embedding(22 => 128), \u001b[90m# 2_816 parameters\u001b[39m\n", - " Chain(\n", - " RandomFourierFeatures{Float32, Matrix{Float32}}(Float32[-2.4796202 13.478667 … 0.7362796 3.2408502]),\n", - " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", - " ),\n", - " [\n", - " TransformerBlock(\n", - " Attention(\n", - " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", - " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", - " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", - " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", - " identity,\n", - " identity,\n", - " Onion.var\"#32#34\"(),\n", - " 16,\n", - " 16,\n", - " 8,\n", - " 8,\n", - " ),\n", - " StarGLU(\n", - " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", - " Dense(512 => 128; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", - " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", - " NNlib.swish,\n", - " ),\n", - " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 … 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0], Float32[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 … 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", - " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", - " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", - " ),\n", - " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 … 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0], Float32[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 … 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", - " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", - " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", - " ),\n", - " identity,\n", - " ),\n", - " TransformerBlock(\n", - " Attention(\n", - " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", - " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", - " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", - " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", - " identity,\n", - " identity,\n", - " Onion.var\"#32#34\"(),\n", - " 16,\n", - " 16,\n", - " 8,\n", - " 8,\n", - " ),\n", - " StarGLU(\n", - " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", - " Dense(512 => 128; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", - " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", - " NNlib.swish,\n", - " ),\n", - " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 … 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0], Float32[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 … 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", - " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", - " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", - " ),\n", - " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 … 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0], Float32[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 … 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", - " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", - " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", - " ),\n", - " identity,\n", - " ),\n", - " TransformerBlock(\n", - " Attention(\n", - " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", - " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", - " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", - " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", - " identity,\n", - " identity,\n", - " Onion.var\"#32#34\"(),\n", - " 16,\n", - " 16,\n", - " 8,\n", - " 8,\n", - " ),\n", - " StarGLU(\n", - " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", - " Dense(512 => 128; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", - " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", - " NNlib.swish,\n", - " ),\n", - " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 … 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0], Float32[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 … 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", - " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", - " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", - " ),\n", - " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 … 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0], Float32[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 … 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", - " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", - " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", - " ),\n", - " identity,\n", - " ),\n", - " TransformerBlock(\n", - " Attention(\n", - " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", - " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", - " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", - " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", - " identity,\n", - " identity,\n", - " Onion.var\"#32#34\"(),\n", - " 16,\n", - " 16,\n", - " 8,\n", - " 8,\n", - " ),\n", - " StarGLU(\n", - " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", - " Dense(512 => 128; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", - " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", - " NNlib.swish,\n", - " ),\n", - " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 … 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0], Float32[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 … 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", - " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", - " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", - " ),\n", - " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 … 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0], Float32[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 … 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", - " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", - " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", - " ),\n", - " identity,\n", - " ),\n", - " ],\n", - " Dense(128 => 20; bias=false), \u001b[90m# 2_560 parameters\u001b[39m\n", - " Dense(128 => 20; bias=false), \u001b[90m# 2_560 parameters\u001b[39m\n", - " Dense(128 => 1; bias=false), \u001b[90m# 128 parameters\u001b[39m\n", - " RoPE{Matrix{Float32}}(Float32[1.0 0.5403023 … -0.87528455 -0.065975994; 1.0 0.95041525 … 0.9552474 0.8159282; … ; 1.0 0.9999995 … -0.57972294 -0.5789079; 1.0 0.99999994 … 0.2726629 0.27235872], Float32[0.0 0.84147096 … -0.48360822 -0.9978212; 0.0 0.3109836 … 0.29580808 0.5781532; … ; 0.0 0.0009999999 … -0.8148137 -0.8153929; 0.0 0.0003162278 … 0.9621096 0.9621958]),\n", - " 20,\n", - ") \u001b[90m # Total: 82 trainable arrays, \u001b[39m1_339_392 parameters,\n", - "\u001b[90m # plus 3 non-trainable, 65_600 parameters, summarysize \u001b[39m5.364 MiB." - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" } ], "source": [ @@ -489,6 +339,7 @@ "K = PM.K\n", "println(\"K: \", K)\n", "\n", + "#alpha_exponent = 3.0f0\n", "P = FF.EditFlow(K; bos_token=0)\n", "\n", "model = EditFlowModel(; d=128, num_heads=8, nlayers=4, rff_dim=128, cond_dim=128, K=K)\n", @@ -497,7 +348,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 53, "metadata": {}, "outputs": [ { @@ -507,359 +358,1319 @@ "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04359362f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.042582143f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.053738564f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.051574655f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04167632f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.040682144f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03297082f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03176706f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.042898107f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04301755f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.047004897f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.047801197f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.031407103f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03131537f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.030527484f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.025587518f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.041389197f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.040904406f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.051030993f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.051154993f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.0374101f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.038289122f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04102195f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.040351614f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.026533976f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.026478458f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.0499959f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.052063473f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.025252756f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.02528245f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.0484398f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.049059216f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.045012593f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.045367613f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.0026780209f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.0028266194f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.022234883f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.021066202f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.033060875f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.033532213f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.040637895f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.038553096f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.040437073f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04018806f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.043794483f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04420363f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.046099633f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.046000928f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03347337f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.032879625f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04562903f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04658139f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.032486565f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.033914283f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.043220945f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.044273406f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.0533192f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.053182956f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.051970646f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.051027846f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04268508f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.043055456f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.035433292f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.0364012f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03389576f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.033408396f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.036275387f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03524468f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.045071315f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.046422645f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.045323465f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04579732f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.056931026f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.056083847f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.026995188f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.02740052f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03336398f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.036104627f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.039238736f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.040208943f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.029019509f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.029784188f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.029877104f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.031641074f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04230904f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04278183f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.044586718f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.045025032f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.055617556f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.05684315f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.038598303f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.038700566f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.036317915f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.037000623f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.047106896f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.047675125f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.02729911f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03150429f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.056716956f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.05844419f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.024726644f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.026736975f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.031491946f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.029746149f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.034738377f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.035454303f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.049314383f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.049596604f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.022996385f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.02378349f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.043030504f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.043790184f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.030262893f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03123553f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04733412f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04705058f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03622381f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.037064686f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04362139f0\n" - ] - }, - { - "data": { - "text/plain": [ - "EditFlowModel(\n", - " Embedding(22 => 128), \u001b[90m# 2_816 parameters\u001b[39m\n", - " Chain(\n", - " RandomFourierFeatures{Float32, Matrix{Float32}}(Float32[-2.4796202 13.478667 … 0.7362796 3.2408502]),\n", - " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", - " ),\n", - " [\n", - " TransformerBlock(\n", - " Attention(\n", - " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", - " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", - " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", - " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", - " identity,\n", - " identity,\n", - " Onion.var\"#32#34\"(),\n", - " 16,\n", - " 16,\n", - " 8,\n", - " 8,\n", - " ),\n", - " StarGLU(\n", - " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", - " Dense(512 => 128; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", - " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", - " NNlib.swish,\n", - " ),\n", - " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9009282, 0.97761583, 0.9507291, 0.9544557, 0.983698, 0.94406486, 0.91237503, 0.9546408, 0.9400282, 0.93728954 … 0.9278801, 0.9326202, 0.8544071, 0.9115099, 0.8849126, 0.8521641, 0.92149186, 0.98095, 0.93939257, 0.977308], Float32[0.0057168175, -0.009145045, -0.033722285, 0.001512183, 0.01333655, -0.033993997, -0.02151767, 0.025952183, 0.039521635, 0.018975694 … 0.0032535498, 0.038781144, -0.010275906, -0.007902587, 0.0082089575, 0.015708515, 0.0030700988, 0.0059594186, -0.03405106, 0.016013626], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", - " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", - " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", - " ),\n", - " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9623362, 0.93352437, 0.93379855, 0.9493948, 1.028554, 0.9743394, 0.8508891, 0.98132527, 0.9344278, 0.9350113 … 0.9744629, 0.9529613, 0.9621484, 0.9163794, 0.94755214, 0.9175964, 0.96506524, 0.9665524, 0.91546625, 0.9949486], Float32[-0.012049371, 0.013126871, 0.0073394994, -0.012121293, -0.016715286, 0.009123021, 0.12233682, 0.014630274, -0.030255122, 0.008518288 … -0.011132118, 0.01053182, -0.0016366772, -0.032412138, -0.034123607, -0.0029400205, -0.0031507579, 0.021517577, 0.018651018, 0.021760372], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", - " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", - " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", - " ),\n", - " identity,\n", - " ),\n", - " TransformerBlock(\n", - " Attention(\n", - " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", - " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", - " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", - " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", - " identity,\n", - " identity,\n", - " Onion.var\"#32#34\"(),\n", - " 16,\n", - " 16,\n", - " 8,\n", - " 8,\n", - " ),\n", - " StarGLU(\n", - " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", - " Dense(512 => 128; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", - " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", - " NNlib.swish,\n", - " ),\n", - " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.88897645, 0.9766103, 0.9197018, 0.9204043, 0.9459889, 0.998207, 0.9029781, 0.9129902, 0.9343188, 0.90026766 … 0.90041107, 0.95305324, 0.93125725, 0.93120664, 0.96174604, 0.92172164, 0.95484656, 0.9365054, 0.94726926, 0.95914537], Float32[-0.024876244, -0.013372403, -0.023151278, 0.0058930805, 0.015150687, 0.00506514, 0.06569516, 0.039223198, -0.022336751, -0.0075592464 … 0.020853924, 0.020920396, 0.022881962, -0.014029156, -0.025372026, -0.030799348, -0.0028562285, 0.016975688, -0.02693857, 0.014985809], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", - " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", - " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", - " ),\n", - " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.8949334, 0.96080613, 0.97868085, 0.9332595, 0.99603575, 0.9822569, 0.81842166, 1.0786498, 0.82465905, 1.0236325 … 1.0279346, 0.99247783, 0.9598536, 1.0668865, 1.0348728, 0.97679406, 1.1416314, 0.9691545, 0.9829652, 0.9567631], Float32[-0.028586997, 0.022033295, 0.0043230234, -0.017253224, 0.018280348, -0.0046796706, 0.1579363, 0.015386374, -0.13737288, -0.01732349 … -0.002627133, 0.012623082, 0.026784712, -0.03556591, -0.008950267, -0.0015624083, -0.043819655, -0.023381405, 0.017168993, -0.01367464], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", - " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", - " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", - " ),\n", - " identity,\n", - " ),\n", - " TransformerBlock(\n", - " Attention(\n", - " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", - " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", - " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", - " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", - " identity,\n", - " identity,\n", - " Onion.var\"#32#34\"(),\n", - " 16,\n", - " 16,\n", - " 8,\n", - " 8,\n", - " ),\n", - " StarGLU(\n", - " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", - " Dense(512 => 128; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", - " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", - " NNlib.swish,\n", - " ),\n", - " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.93196476, 0.96928746, 0.99993956, 0.966561, 0.97282875, 0.9290628, 0.86543846, 0.9901893, 0.9423256, 0.9461345 … 0.9819104, 0.9650237, 0.97143203, 1.0043927, 1.0046741, 0.9852849, 0.9995551, 0.94403285, 0.9784962, 0.9999178], Float32[0.005265708, -0.02571394, 0.0072728144, -0.002272927, -0.011670859, 0.01575806, 0.071842745, 0.0057321745, -0.01695154, 0.0033025448 … -0.035389263, -0.0024997725, -0.011022158, 0.0042375517, -0.028677516, -0.0134365475, -0.033173997, 0.00831741, -0.011757645, 0.014898374], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", - " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", - " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", - " ),\n", - " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9558336, 0.97751004, 0.97629535, 1.0008391, 1.027303, 0.9920142, 0.93847626, 1.0232522, 0.97007394, 0.98495865 … 0.975234, 0.98128086, 1.0140299, 0.961463, 1.0209244, 0.9895201, 1.0035169, 0.9764949, 0.9712956, 0.9992766], Float32[-0.035114158, 0.009441036, 0.0013764837, -0.01886956, -0.013361261, 0.02365774, 0.07090634, 0.0082793, -0.067354, -0.03893483 … -0.0047005075, -0.009805776, 0.02273551, -0.021179873, -0.021423183, -0.032671858, -0.033467315, -0.034345157, -0.01578475, -0.010036208], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", - " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", - " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", - " ),\n", - " identity,\n", - " ),\n", - " TransformerBlock(\n", - " Attention(\n", - " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", - " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", - " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", - " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", - " identity,\n", - " identity,\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04445659f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 11\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.051929086f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 11\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.02436034f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 11\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.022771671f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 11\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.044702657f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 11\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.045137305f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 11\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.041192025f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 12\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.029864756f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 12\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.038833927f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 12\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.041693743f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 12\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.023466088f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 12\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.046086684f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 12\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04445929f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 13\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.05211716f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 13\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.036415737f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 13\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.035114527f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 13\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.05363507f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 13\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.031739093f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 13\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.034422822f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 14\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.045822714f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 14\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03548678f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 14\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04809461f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 14\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.040762138f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 14\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.022662576f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 14\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.034381583f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 15\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.02072578f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 15\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04044771f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 15\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.043389153f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 15\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.033454575f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 15\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.02941765f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 15\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03229374f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 16\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.030144595f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 16\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04410399f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 16\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.014296858f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 16\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.045350045f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 16\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.01808934f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 16\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.037948772f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 17\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.040850688f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 17\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.047814716f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 17\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03897f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 17\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.039783433f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 17\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.046952866f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 17\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.050687954f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 18\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.027305104f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 18\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.034051463f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 18\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04046725f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 18\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.035221793f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 18\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.015419234f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 18\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.032407716f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 19\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03907629f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 19\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04017909f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 19\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.042050876f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 19\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.06224002f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 19\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.032651253f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 19\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.034311622f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 20\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.050489604f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 20\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.01942078f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 20\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04674881f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 20\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.031366825f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 20\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.030259585f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 20\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.020899203f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 21\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03374313f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 21\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.026232053f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 21\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03176389f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 21\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04193217f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 21\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.039803006f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 21\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.0016402872f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 22\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.034368455f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 22\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.044954106f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 22\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.049633063f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 22\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.051525604f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 22\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.039586365f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 22\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.056642942f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 23\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04322856f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 23\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03591118f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 23\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.039617103f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 23\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.033589836f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 23\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.045645736f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 23\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04366725f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 24\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04571055f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 24\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04562773f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 24\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.037686266f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 24\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04003264f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 24\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03928131f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 24\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04958935f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 25\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.044996995f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 25\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.017311074f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 25\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03966754f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 25\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.045690224f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 25\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.045542553f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 25\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.043954458f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 26\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.02862454f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 26\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.027264602f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 26\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.040636502f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 26\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04547987f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 26\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03184007f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 26\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04121754f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 27\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.046075374f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 27\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.042077787f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 27\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.02793716f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 27\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.047131248f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 27\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.031824037f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 27\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.049015008f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 28\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03991092f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 28\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.041570164f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 28\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.031357594f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 28\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.023561478f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 28\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.015707273f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 28\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04599042f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 29\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.035853077f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 29\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.043617148f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 29\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03299003f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 29\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.036430042f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 29\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.041398343f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 29\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.004706221f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 30\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.037196025f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 30\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.05408126f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 30\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.040643804f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 30\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.028125618f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 30\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.039175157f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 30\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.046623144f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 31\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03860229f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 31\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04580462f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 31\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.026982484f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 31\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.01907624f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 31\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.033030905f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 31\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04366968f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 32\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.019387946f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 32\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.041732203f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 32\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.038875856f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 32\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.033090573f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 32\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03511978f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 32\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.049247496f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 33\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.034137912f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 33\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.025268145f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 33\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04250137f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 33\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.035059683f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 33\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.020794798f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 33\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.045273773f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 34\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.028975278f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 34\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03930358f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 34\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.025179597f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 34\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.026635196f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 34\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.038387585f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 34\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03936877f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 35\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.041131224f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 35\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.037794285f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 35\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.031822115f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 35\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.0286325f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 35\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03954857f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 35\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.034084857f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 36\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.032853782f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 36\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.015939223f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 36\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.038161334f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 36\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.044323556f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 36\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.021606334f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 36\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.024146589f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 37\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.046376158f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 37\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04099659f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 37\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.0414833f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 37\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.027421055f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 37\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.05385631f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 37\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03387799f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 38\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03678792f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 38\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03864511f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 38\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.031337883f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 38\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.035680942f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 38\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.028983377f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 38\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.022545489f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 39\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.033676624f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 39\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04305654f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 39\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.018965978f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 39\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03362689f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 39\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.026229195f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 39\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.033605922f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 40\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.02983573f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 40\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.040450968f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 40\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.042170297f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 40\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.014729615f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 40\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.034614924f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 40\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03768231f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 41\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.032214597f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 41\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04054915f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 41\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.05015796f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 41\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.046196725f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 41\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.034610253f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 41\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.024003044f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 42\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03458842f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 42\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04691034f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 42\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.035118952f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 42\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.028442157f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 42\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.037072852f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 42\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.017393941f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 43\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03015057f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 43\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.036646903f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 43\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.028592978f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 43\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.047810607f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 43\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04006023f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 43\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.029726554f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 44\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.038993478f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 44\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.036169015f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 44\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.035097905f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 44\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.036238242f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 44\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.013541234f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 44\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.040243626f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 45\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.042542692f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 45\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.032190338f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 45\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03143801f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 45\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.011104978f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 45\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04108549f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 45\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.021270731f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 46\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.030110102f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 46\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.04132489f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 46\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.014701558f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 46\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.038577426f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 46\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.013419241f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 46\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.036465287f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 47\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.0129490765f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 47\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.042824633f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 47\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03329256f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 47\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.038794056f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 47\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.042093784f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 47\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.039231405f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 48\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.016737167f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 48\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03380588f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 48\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.032274134f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 48\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03857955f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 48\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.035523675f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 48\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03874997f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 49\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.032295678f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 49\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.031139178f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 49\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03532363f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 49\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.034379814f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 49\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.021528132f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 49\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.03387867f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 50\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.015707625f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 50\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.027938733f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 50\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.031691514f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 50\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.035845827f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 50\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.038091443f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain-gapwise\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 50\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 0.042518776f0\n" + ] + }, + { + "data": { + "text/plain": [ + "EditFlowModel(\n", + " Embedding(22 => 128), \u001b[90m# 2_816 parameters\u001b[39m\n", + " Chain(\n", + " RandomFourierFeatures{Float32, Matrix{Float32}}(Float32[-3.4897678 12.4698105 … 6.522122 -6.1615295]),\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " [\n", + " TransformerBlock(\n", + " Attention(\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " identity,\n", + " identity,\n", + " Onion.var\"#32#34\"(),\n", + " 16,\n", + " 16,\n", + " 8,\n", + " 8,\n", + " ),\n", + " StarGLU(\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(512 => 128; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " NNlib.swish,\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9485438, 0.9517056, 0.91631305, 0.93132836, 0.8952846, 0.9048501, 0.9849782, 0.97568834, 0.9770145, 0.9543596 … 0.95225495, 0.9640162, 0.96162915, 0.95250344, 0.9518388, 0.93140155, 0.95342207, 0.9564777, 0.9472097, 0.9704547], Float32[-0.0025767968, -0.005531265, -0.057881825, -0.0020387296, -0.011449936, -0.011851602, 0.002365834, -0.011678252, -0.014808152, 0.009572189 … 0.0022765587, -0.020436158, -0.015536882, 0.0023218014, 7.319261f-5, 0.00029178447, 0.010181397, -0.008527656, 0.00060043234, 0.009188443], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.92454726, 1.0295289, 0.98453337, 1.0147902, 0.9616023, 0.9640124, 0.96462286, 0.95139396, 0.968303, 1.0446378 … 0.97232085, 0.9544489, 0.94105947, 1.01344, 0.97555476, 0.9792089, 1.0025232, 0.95133525, 0.9576563, 1.0143557], Float32[0.0027763864, -0.00047614917, -0.015428355, 0.021620063, -0.017400159, 0.005237624, -0.015351549, -0.012930975, -0.02459172, -0.017333504 … -0.010810377, -0.015740385, -0.009417565, 0.008541248, 0.00019140948, -0.005366987, -0.0088723535, 0.005091113, 0.0075245644, 0.026632788], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " identity,\n", + " ),\n", + " TransformerBlock(\n", + " Attention(\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " identity,\n", + " identity,\n", + " Onion.var\"#32#34\"(),\n", + " 16,\n", + " 16,\n", + " 8,\n", + " 8,\n", + " ),\n", + " StarGLU(\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(512 => 128; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " NNlib.swish,\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9579994, 0.9476913, 0.9554934, 0.9522036, 0.9599546, 0.9532042, 0.9783103, 0.9622565, 0.9757522, 0.9626176 … 0.97050655, 0.87086666, 0.97092474, 0.9631059, 0.97171074, 0.96746814, 0.97048044, 0.9612386, 0.9372323, 0.97935456], Float32[-0.01209553, -0.010203717, -0.010120125, -0.0020847165, 0.011635498, 0.00048273787, -0.007999752, 6.894706f-5, -0.021175401, -0.0140660945 … -0.0046253526, -0.0031032036, -0.012982736, 0.03514903, 0.0010869585, -0.013199106, -0.0038628152, -0.002296497, 0.02071869, 0.011734843], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.985139, 0.9774747, 1.0477108, 0.98501253, 0.98935205, 0.9846256, 0.9944955, 0.9971468, 0.98940533, 1.011992 … 0.94710165, 1.0043437, 1.0460154, 1.0454555, 0.97295123, 1.0074944, 1.0127513, 1.004472, 1.0336586, 0.98678666], Float32[0.009985156, 0.0148912845, 0.0007550778, 0.013916604, -0.0054427087, -0.0115058925, 0.016221523, 0.00095696026, -0.010937472, -0.013677097 … -0.013091496, 0.0013413352, -0.013482028, 0.00044459678, -0.0081370445, -0.02209245, -0.015265387, -0.00967068, 0.0014689483, 0.0148694515], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " identity,\n", + " ),\n", + " TransformerBlock(\n", + " Attention(\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " identity,\n", + " identity,\n", + " Onion.var\"#32#34\"(),\n", + " 16,\n", + " 16,\n", + " 8,\n", + " 8,\n", + " ),\n", + " StarGLU(\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(512 => 128; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " NNlib.swish,\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9705351, 1.0028347, 0.9740206, 0.969771, 0.9363874, 0.9498614, 0.9676518, 0.9835581, 0.9829488, 0.9746027 … 1.003019, 0.9874021, 0.9921866, 0.95297444, 0.9610126, 0.98681086, 0.98136693, 0.9986948, 0.9301441, 0.9700858], Float32[-0.0007444257, -0.029364536, -0.0039363527, -0.000186554, -0.005866427, -0.009861192, -0.002090479, -0.0008000579, 0.008326826, -0.019328756 … 0.008347517, 0.00077981426, -0.0090034325, 0.0023879372, -0.014871054, -0.02297807, 0.0025592789, -0.0046469, 0.011648754, 0.023409285], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[1.0317453, 1.0391508, 1.0567257, 0.9506647, 1.0375222, 0.95721054, 0.99698806, 1.0370752, 1.0125376, 1.0758225 … 1.0426638, 1.0156405, 1.1337172, 0.98136586, 0.99563056, 1.0322379, 1.0522087, 1.0129474, 1.0208626, 0.98538053], Float32[-0.021828685, 0.016727783, -0.014718995, 0.017482841, 0.0045893975, -0.029517096, -0.018830335, 0.0072353478, -0.014692814, -0.0018668761 … 0.0047888295, -0.013738959, -0.02322664, -0.010887477, -0.01950592, -0.007834701, -0.00089994207, 0.006822281, 0.005051074, 0.02711348], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " identity,\n", + " ),\n", + " TransformerBlock(\n", + " Attention(\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " identity,\n", + " identity,\n", " Onion.var\"#32#34\"(),\n", " 16,\n", " 16,\n", @@ -873,12 +1684,12 @@ " NNlib.swish,\n", " ),\n", " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.93987024, 1.0141299, 0.94590473, 1.0398, 0.9685555, 0.9711986, 0.8357142, 0.9902968, 0.9614973, 0.986233 … 0.97533554, 0.99850684, 0.9468865, 0.9574326, 0.9989692, 0.9406473, 0.95291144, 0.9222057, 0.8843927, 0.97842926], Float32[-0.0002878682, -0.02697671, -0.011184995, 0.003966876, -0.009137481, -0.014782035, 0.075821735, -0.003926014, -0.04380838, 7.698221f-5 … -0.038504954, 0.010956845, 0.034050774, -0.016015368, -0.014015871, -0.019414632, -0.030451395, -0.0155181745, -0.030340765, 0.0006519265], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9345033, 1.0022833, 0.9521148, 0.9575872, 0.8875572, 1.0460182, 0.9967136, 1.0072346, 0.9725838, 1.0341343 … 0.99518543, 0.98995036, 1.0307875, 1.0181413, 1.0229013, 0.9724673, 0.96660626, 1.0165946, 0.8986929, 0.9959466], Float32[-0.043202747, 0.004392449, 0.005028139, 0.033483025, -0.0054316483, -0.005291531, -0.022794988, -0.014869429, 0.013712466, -0.023869297 … 0.020763112, -0.008715548, 0.0013027693, 0.0014196149, 0.0013407562, -0.026271563, 0.013075633, -0.009605205, 0.0029699882, 0.005611375], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " ),\n", " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.99015504, 0.9972736, 0.9607575, 0.9881008, 1.0271544, 0.97107905, 0.9632005, 0.9456777, 0.94125587, 0.97891855 … 0.9640415, 0.96021736, 0.9862009, 1.017604, 0.94475704, 1.0080596, 1.0486706, 0.9568705, 1.0038033, 0.97236484], Float32[-0.03507125, 0.013651431, 0.009977945, -0.0022944945, -0.011060834, 0.042574823, 0.078900285, -0.012326445, -0.079122104, -0.0453799 … -0.020229638, -0.008847884, 0.0003417767, -0.07078015, -0.046866, -0.044151116, -0.053207915, -0.044059698, -0.008748555, 0.0016865802], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[1.0118818, 1.0250593, 1.0372803, 0.9790395, 1.0693208, 1.015231, 1.0267678, 1.0174215, 1.0019836, 1.0813804 … 1.043039, 1.0293376, 1.194062, 0.99059707, 1.0406202, 0.9874126, 1.0517399, 1.0073861, 1.0147883, 1.0668176], Float32[0.0047795386, -0.0060442886, -0.008400408, 0.029895015, -0.015548748, -0.022354802, -0.019373512, 0.023813745, -0.018122695, -0.007683282 … 0.005050846, -0.027234506, -0.0535788, -0.02090459, -0.0033181268, -0.032578275, 0.02245798, 0.00907158, 0.009862278, 0.0163724], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " ),\n", @@ -894,19 +1705,19 @@ "\u001b[90m # plus 3 non-trainable, 65_600 parameters, summarysize \u001b[39m5.364 MiB." ] }, - "execution_count": 16, + "execution_count": 53, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Train; returned model is on CPU\n", - "model = train_editflow!(P, model; epochs=10, steps_per_epoch=150, batch_size=256, lr=1f-3)\n" + "model = train_editflow!(P, model; epochs=50, steps_per_epoch=150, batch_size=256, lr=3f-4)\n" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -914,27 +1725,44 @@ "output_type": "stream", "text": [ "\n", - "=== Gap-wise model samples (20) ===\n", - "[1] EVQVNESGKGL\n", - "[2] VVFLVQSGGGLVKKPGASVKVQ\n", - "[3] VQLVQGGVNLVKPGSAVKKP\n", - "[4] QVQVSGAMKRPG\n", - "[5] QVQLVKSGPGLVKPG\n", - "[6] QVQLRQSGYAEVKKPR\n", - "[7] EVELLRSGVLVKPGGD\n", - "[8] QVQLLVQSGAEVK\n", - "[9] EVHLRESGLGGLPS\n", - "[10] QVQRVQQDVKMPGA\n", - "[11] EVQLVHSGGG\n", - "[12] QLQLQESGGGLVQPGGSR\n", - "[13] QVQAQAGEAGVKP\n", - "[14] QVQLVQSGANVKRKGSS\n", - "[15] EVQLVESGGGLVPGSGLLRL\n", - "[16] VLQVQSRGVLVKPNGSVKK\n", - "[17] QVTLRRDSTSLVKKP\n", - "[18] QVQLVHSAEVK\n", - "[19] EVQLVLSGGGILRK\n", - "[20] EVQLVESGGGLV\n" + "=== Gap-wise model samples (20) ===\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[33m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[33m\u001b[1mWarning: \u001b[22m\u001b[39mLayer with Float32 parameters got Float64 input.\n", + "\u001b[33m\u001b[1m│ \u001b[22m\u001b[39m The input will be converted, but any earlier layers may be very slow.\n", + "\u001b[33m\u001b[1m│ \u001b[22m\u001b[39m layer = Dense(128 => 128; bias=false) \u001b[90m# 16_384 parameters\u001b[39m\n", + "\u001b[33m\u001b[1m│ \u001b[22m\u001b[39m summary(x) = \"128×2 Matrix{Float64}\"\n", + "\u001b[33m\u001b[1m└ \u001b[22m\u001b[39m\u001b[90m@ Flux ~/.julia/packages/Flux/uRn8o/src/layers/stateless.jl:60\u001b[39m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1] EVHLQESGGGL\n", + "[2] QVQLVQSGAGVKPSTNTVPVSVE\n", + "[3] QVQLVQSKAEVKKHGGASVK\n", + "[4] EVQLVSYGGRVKK\n", + "[5] QVQLQQGYGAKKKVK\n", + "[6] QVQLVQSGAE\n", + "[7] QVQLVQSGAEVK\n", + "[8] QVQLVQSGAAVE\n", + "[9] VVQLVESGGGLVK\n", + "[10] QVQLVQSSGAEVSKPWGA\n", + "[11] QVQLQECGKGLNQH\n", + "[12] LVQLVQGSAEVKKK\n", + "[13] QVQLVQSGAEVKKPGASVK\n", + "[14] QVLVQSGAEVMVKPGA\n", + "[15] QQVKVQSGAEVKVKPG\n", + "[16] QVLLVQSGAQV\n", + "[17] EVQVESSGGGPTSP\n", + "[18] QVQLQESGGLVEKP\n", + "[19] QVQLQESGGGVKVPK\n", + "[20] EVQLVESGGGLVL\n" ] } ], @@ -968,231 +1796,277 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 81, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "500-element Vector{String}:\n", + " \"EVQLVESGGGLQLP\"\n", + " \"QVQLVESGGGVVQPGRS\"\n", + " \"QVQLKQSGAEVKKPSGAAVE\"\n", + " \"VQLVESGGGDVKPGGSLRL\"\n", + " \"QVQLQESGPGGLVK\"\n", + " \"QVQLVQSGAEVKK\"\n", + " \"EVQLVESGGGLVKPSGT\"\n", + " \"QVQVYQVGSETQKRP\"\n", + " \"EVQLLESGGVLVQP\"\n", + " \"QVQLVQSGAEVWK\"\n", + " \"EVQLVDSGGGLV\"\n", + " \"QVELRESGRVMVHPRG\"\n", + " \"VQLVQSGAEVK\"\n", + " ⋮\n", + " \"QVQVLEGGGGVVQPSRLSAK\"\n", + " \"EVQLVESGGGLVQP\"\n", + " \"QVQLVQSGARVKKPEAS\"\n", + " \"QVEGQQMGAGVKRG\"\n", + " \"EVYLVQPYESGYLQTGSLFL\"\n", + " \"QVMLQESGPGLVVK\"\n", + " \"EVQLVESGGGLVQPGKS\"\n", + " \"QVQLVQSGAEVKKPGSSV\"\n", + " \"EVQLVASGHVLVQTLS\"\n", + " \"QVQLVQSGAEVVKPSET\"\n", + " \"QVQLVQSQAETKKP\"\n", + " \"QVQLVQSGAVKKPGASVK\"" + ] + }, + "execution_count": 81, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Sampling and Levenshtein plot\n", + "using Random\n", + "n = 500\n", + "\n", + "model_strings = sample_gapwise_strings(P, model; N=n, ts=ts, rng=rng)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 83, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "image/svg+xml": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ], "text/html": [ - "" + "" ] }, - "execution_count": 17, + "execution_count": 83, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# Sampling and Levenshtein plot\n", - "using Random\n", - "n = 500\n", "\n", - "#ts = 0.0f0:0.01f0:1.0f0\n", - "model_strings = sample_gapwise_strings(P, model; N=n, ts=ts, rng=rng)\n", "\n", + "n2 = 500\n", "# Build training strings from PM parents (the data PM was built on)\n", - "train_states = [FF.DiscreteState(P.k, sample(PM; rng=Random.MersenneTwister(1000+i))) for i in 1:n]\n", + "train_states = [FF.DiscreteState(P.k, sample(PM; rng=Random.MersenneTwister(1000+i))) for i in 1:n2]\n", "train_strings = [state_to_PM_string(P, s) for s in train_states]\n", "\n", "# Independent validation strings sampled from PM\n", - "val_states = [FF.DiscreteState(P.k, sample(PM; rng=Random.MersenneTwister(1000+i+2*n))) for i in 1:n]\n", + "val_states = [FF.DiscreteState(P.k, sample(PM; rng=Random.MersenneTwister(1000+i+2*n2))) for i in 1:n2]\n", "val_strings = [state_to_PM_string(P, s) for s in val_states]\n", - "val_strings = [s for s in val_strings if !(s in train_strings)]\n", + "#val_strings = [s for s in val_strings if !(s in train_strings)]\n", "\n", "# Plot normalized Levenshtein vs. training set (distinct val/train)\n", "plt = plot_lev_dist(\"model_vs_true\", val_strings, model_strings, train_strings; title=\"Model vs True (normalized Levenshtein)\")" @@ -1200,192 +2074,259 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "100000-element Vector{String}:\n", + " \"EVQDVESGGGLV\"\n", + " \"EVQSVESGGGLVKPGGSLR\"\n", + " \"QVQLVPSGAAVKKP\"\n", + " \"SVQLVQSGAEVKKP\"\n", + " \"QVQLVQSWADCKKPLASVEV\"\n", + " \"EVQLVQSGGGLVQTGGS\"\n", + " \"EVQLLESGGGLVQ\"\n", + " \"QPQLVKPGDEVKKPGASVKV\"\n", + " \"FVTLRDSVALV\"\n", + " \"QITLKESDPTNVKP\"\n", + " \"QVQLVKSGAEV\"\n", + " \"QVQLVQSGPEVKKP\"\n", + " \"QVQKVQSGAEVKRP\"\n", + " ⋮\n", + " \"QVQLQNSGPGLVK\"\n", + " \"QVQLQQSGPGLVKPSQTLSL\"\n", + " \"QEKGGQEGGKV\"\n", + " \"QVQLVQSGAEVKKP\"\n", + " \"QVQLVESGGGVVQPGRSLR\"\n", + " \"QVQLVQSGAAV\"\n", + " \"QVQLVESGGG\"\n", + " \"EVNLVESMGGL\"\n", + " \"QVQLVQSGIAVKKPGA\"\n", + " \"QVQLPQSGAEVKKPGASVK\"\n", + " \"QVQLQESGPGLVK\"\n", + " \"QVQLVQSGAEVKKPGS\"" + ] + }, + "execution_count": 78, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model_samples_any = sample_gen_n(P, model; n=10, ts=0f0:0.01f0:1f0, rng=Random.MersenneTwister(42))\n", + "model_final_states = map(final_state_from_gen, model_samples_any)\n", + "model_strings_old = [state_to_PM_string(P, s) for s in model_final_states]\n", + "\n", + "n3 = 500\n", + "# Build training strings from PM parents (the data PM was built on)\n", + "train_states = [FF.DiscreteState(P.k, sample(PM; rng=Random.MersenneTwister(1000+i))) for i in 1:n3]\n", + "train_strings = [state_to_PM_string(P, s) for s in train_states]\n", + "\n", + "# Independent validation strings sampled from PM\n", + "val_states = [FF.DiscreteState(P.k, sample(PM; rng=Random.MersenneTwister(1000+i+2*n3))) for i in 1:n3]\n", + "val_strings = [state_to_PM_string(P, s) for s in val_states]\n", + "#val_strings = [s for s in val_strings if !(s in train_strings)]\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(\"Hej\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "image/svg+xml": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ], "text/html": [ - "" + "" ] }, "metadata": {}, @@ -1393,207 +2334,193 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "image/svg+xml": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ], "text/html": [ - "" + "" ] }, "metadata": {}, diff --git a/editflow_code/helper_funcs.jl b/editflow_code/helper_funcs.jl index e63df9a..6a27246 100644 --- a/editflow_code/helper_funcs.jl +++ b/editflow_code/helper_funcs.jl @@ -28,7 +28,23 @@ function sample_gen_n(P::FF.EditFlow, model; n::Int=10, ts=0f0:0.01f0:1f0, rng=R bos = P.bos_token toks = collect(FF.tensor(x0s[1])) x0_bos = FF.DiscreteState(P.k, vcat([bos], toks)) - gens[i] = FF.gen(P, x0_bos, model, ts) + res = FF.gen(P, x0_bos, model, ts) + # Strip BOS token(s) from outputs + strip_bos_state(st::FF.DiscreteState) = begin + xs = collect(FF.tensor(st)) + if !isempty(xs) && xs[1] == bos + FF.DiscreteState(P.k, xs[2:end]) + else + st + end + end + if res isa FF.DiscreteState + gens[i] = strip_bos_state(res) + elseif res isa AbstractVector{<:FF.DiscreteState} + gens[i] = strip_bos_state.(res) + else + gens[i] = res + end end return gens end diff --git a/editflow_code/test/analysis_notebook.ipynb b/editflow_code/test/analysis_notebook.ipynb new file mode 100644 index 0000000..662e339 --- /dev/null +++ b/editflow_code/test/analysis_notebook.ipynb @@ -0,0 +1,3753 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m\u001b[1m Activating\u001b[22m\u001b[39m project at `~/dev/Flowfusion.jl/editflow_code`\n", + "\u001b[32m\u001b[1m Resolving\u001b[22m\u001b[39m package versions...\n", + "\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `~/dev/Flowfusion.jl/editflow_code/Project.toml`\n", + "\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `~/dev/Flowfusion.jl/editflow_code/Manifest.toml`\n", + "WARNING: using StatsBase.sample in module Main conflicts with an existing identifier.\n" + ] + }, + { + "data": { + "text/plain": [ + "plot_len_dist (generic function with 1 method)" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using Pkg\n", + "Pkg.activate(@__DIR__)\n", + "Pkg.instantiate()\n", + "using Revise\n", + "\n", + "using Random\n", + "using Statistics\n", + "using Adapt\n", + "using Functors\n", + "using Flux\n", + "using Onion\n", + "using RandomFeatureMaps\n", + "using Zygote\n", + "\n", + "Pkg.develop(path=joinpath(@__DIR__, \"..\"))\n", + "using Flowfusion\n", + "const FF = Flowfusion\n", + "\n", + "include(joinpath(@__DIR__, \"prob_model.jl\"))\n", + "include(joinpath(@__DIR__, \"helper_funcs.jl\"))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "to_same_device (generic function with 1 method)" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import CUDA\n", + "\n", + "# Device helpers\n", + "const _gpu_enabled = try\n", + " CUDA.has_cuda()\n", + "catch\n", + " false\n", + "end\n", + "\n", + "to_dev(x) = _gpu_enabled ? Adapt.adapt(CUDA.CuArray, x) : x\n", + "to_cpu(x) = _gpu_enabled ? Adapt.adapt(Array, x) : x\n", + "# move x to the same device type as y (Array or CuArray)\n", + "to_same_device(x, y) = (_gpu_enabled && (y isa CUDA.CuArray)) ? Adapt.adapt(CUDA.CuArray, x) : Adapt.adapt(Array, x)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "make_minibatch (generic function with 1 method)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Minibatch builder (uses true PM)\n", + "function make_minibatch(B::Int, P::FF.EditFlow; rng=Random.default_rng())\n", + " K = P.k\n", + " x0s = Vector{FF.DiscreteState}(undef, B)\n", + " x1s = Vector{FF.DiscreteState}(undef, B)\n", + " for b in 1:B\n", + " # x1 from true PM\n", + " seq1 = sample(PM; rng=rng)\n", + " @assert all(1 .<= seq1 .<= K)\n", + " x1s[b] = FF.DiscreteState(K, seq1)\n", + " # x0: uniform tokens with random length in 1:10 (no BOS in x0)\n", + " L0 = rand(rng, 1:10)\n", + " seq0 = rand(rng, 1:K, L0)\n", + " x0s[b] = FF.DiscreteState(K, seq0)\n", + " end\n", + " ts = rand(rng, Float32, B)\n", + " return x0s, x1s, ts\n", + "end\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "EditFlowModel" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Model definition\n", + "struct EditFlowModel{L}\n", + " layers::L\n", + "end\n", + "Flux.@layer EditFlowModel\n", + "\n", + "function EditFlowModel(; d=128, num_heads=8, nlayers=6, rff_dim=128, cond_dim=128, K::Int)\n", + " embedding = Flux.Embedding(K + 2 => d)\n", + " time_embed = Flux.Chain(RandomFourierFeatures(1 => rff_dim, 1.0f0), Dense(rff_dim => cond_dim))\n", + " blocks = [Onion.AdaTransformerBlock(d, cond_dim, num_heads) for _ in 1:nlayers]\n", + " head_combined = Dense(d => 2K + 1, bias=false)\n", + " rope = RoPE(d ÷ num_heads, 4096)\n", + " return EditFlowModel((; embedding, time_embed, blocks, head_combined, rope, K))\n", + "end\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Forward pass\n", + "function (model::EditFlowModel)(t, Xt_ms)\n", + " m = model.layers\n", + " X = FF.tensor(Xt_ms)\n", + " X = ndims(X) == 1 ? reshape(X, :, 1) : X\n", + " L, B = size(X)\n", + "\n", + " pmask = Zygote.@ignore FF.getlmask(Xt_ms)\n", + " Xp = X .+ 1\n", + " H = m.embedding(Xp)\n", + "\n", + " t = ndims(t) == 0 ? fill(Float32(t), B) : Float32.(t)\n", + " cond = m.time_embed(reshape(t, 1, B))\n", + "\n", + " cond = to_same_device(cond, H)\n", + " pmask = Zygote.@ignore to_same_device(pmask, H)\n", + " rope = Zygote.@ignore to_same_device(m.rope[1:L], H)\n", + "\n", + " for blk in m.blocks\n", + " H = blk(H; cond, rope, kpad_mask=pmask)\n", + " end\n", + " return m.head_combined(H)\n", + "end\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "train_editflow! (generic function with 1 method)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Training (GPU if available)\n", + "function train_editflow!(P::FF.EditFlow,\n", + " model;\n", + " epochs::Int=1,\n", + " steps_per_epoch::Int=100,\n", + " batch_size::Int=64,\n", + " lr::Float32=1f-2,\n", + " seed::Int=42,\n", + " print_every::Int=25)\n", + "\n", + " rng = Random.MersenneTwister(seed)\n", + " Random.seed!(seed)\n", + "\n", + " # Move model to device (GPU if available)\n", + " model = Functors.fmap(to_dev, model)\n", + " opt_state = Flux.setup(Flux.Adam(lr), model)\n", + "\n", + " for epoch in 1:epochs\n", + " for step in 1:steps_per_epoch\n", + "\n", + " # 1) Minibatch Sampling\n", + " x0s, x1s, ts = make_minibatch(batch_size, P; rng=rng)\n", + "\n", + " # 2) Align and batch\n", + " Z0, Z1 = FF.align_and_batch(P, x0s, x1s)\n", + "\n", + " # 3) Interpolate\n", + " Zt, Xt = FF.interpolate_Z_elementwise(P, Z0, Z1, ts)\n", + "\n", + " # 4) Prepend BOS\n", + " bos = P.bos_token\n", + " Zt = vcat(fill(bos, 1, batch_size), Zt)\n", + " Xt = vcat(fill(bos, 1, batch_size), Xt)\n", + " Z1 = vcat(fill(bos, 1, batch_size), Z1)\n", + " \n", + " # 5) Masks and multipliers\n", + " transition_mask = FF.transition_mask_from_Xt(P, Xt)\n", + " edit_multiplier = FF.remaining_edits(P, Zt, Z1, Xt)\n", + " @assert size(transition_mask) == size(edit_multiplier)\n", + "\n", + " # 6) Scheduler scaling\n", + " den = 1f0 .- P.κ.(ts)\n", + " den = max.(den, 1f-3)\n", + " scheduler_scaling = P.dκ.(ts) ./ den\n", + "\n", + " # 7) Masked state\n", + " lmask = Xt .!= P.padding_token\n", + " cmask = trues(size(lmask))\n", + " Xt_ms = FF.MaskedState(FF.DiscreteState(P.k, Xt), cmask, lmask)\n", + "\n", + " ts_d = to_dev(ts)\n", + " Xt_ms_d = to_dev(Xt_ms)\n", + " Tmask_d = to_dev(transition_mask)\n", + " Emult_d = to_dev(edit_multiplier)\n", + " sched_d = to_dev(reshape(Float32.(scheduler_scaling), 1, 1, :))\n", + "\n", + " # 8) Forward + loss + update\n", + " loss, grad = Flux.withgradient(model) do m\n", + " M = m(ts_d, Xt_ms_d)\n", + " l = FF.edit_loss(P, M, Tmask_d, Emult_d, sched_d; eps=1f-8)\n", + " if isnan(l)\n", + " println(\"Maximum element of M: \", maximum(M))\n", + " end\n", + " l\n", + " end\n", + " Flux.update!(opt_state, model, grad[1])\n", + "\n", + " if step % print_every == 0\n", + " @info \"train\" epoch step loss=Float32(loss)\n", + " end\n", + " end\n", + " end\n", + "\n", + " return Functors.fmap(to_cpu, model)\n", + "end\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Init process and model\n", + "K = PM.K\n", + "P = FF.EditFlow(K; bos_token=0, gap_wise=false)\n", + "model = EditFlowModel(; d=128, num_heads=8, nlayers=4, rff_dim=128, cond_dim=128, K=K)\n", + "nothing" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.746237f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.981628f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.213884f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.454155f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.665428f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.873983f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.157003f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 15.275973f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.903381f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.729305f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.102013f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.672424f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.530746f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.67213f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.382526f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.963814f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.835972f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.291992f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.19426f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.382185f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.135967f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.92569f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.028893f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.427214f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 17.69117f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.73476f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.384754f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.658775f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.132454f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.998142f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.203682f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.36901f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.243134f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.106112f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.82871f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.493202f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.290234f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.923895f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.832842f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.057846f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.94542f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.881554f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.718155f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.733717f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.073797f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.92004f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.047007f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.872967f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.382488f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.645565f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.287525f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.113968f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.087315f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.874767f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.860031f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.602049f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.410063f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 10.562942f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.848387f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.861128f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 11\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.541365f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 11\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.236982f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 11\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.957115f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 11\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.865005f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 11\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.583748f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 11\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.02132f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 12\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.584347f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 12\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.580858f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 12\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.981087f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 12\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.591656f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 12\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.066517f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 12\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.051542f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 13\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.067421f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 13\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.05304f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 13\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.487747f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 13\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.222967f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 13\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.143532f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 13\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.575806f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 14\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.158926f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 14\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.09401f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 14\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.851517f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 14\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.892365f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 14\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.7897f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 14\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.985878f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 15\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.019676f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 15\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.797548f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 15\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.55872f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 15\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.278553f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 15\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.254448f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 15\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.536222f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 16\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.821463f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 16\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 17.80231f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 16\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.376482f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 16\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.044758f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 16\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.442654f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 16\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.176807f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 17\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.091465f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 17\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.013334f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 17\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.81593f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 17\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.212975f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 17\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.84259f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 17\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.185429f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 18\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.470398f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 18\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.427452f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 18\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.94579f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 18\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.695702f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 18\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.645878f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 18\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.073719f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 19\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.841595f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 19\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.278421f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 19\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.68238f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 19\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.269619f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 19\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.283346f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 19\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.181093f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 20\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.541328f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 20\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.628794f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 20\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.634392f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 20\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.7462f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 20\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.353523f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 20\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.927622f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 21\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.720219f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 21\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.47013f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 21\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.810509f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 21\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.401003f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 21\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.512375f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 21\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.377796f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 22\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.350807f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 22\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 16.468513f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 22\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.804567f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 22\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.310434f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 22\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.925941f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 22\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.39031f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 23\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.91434f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 23\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.262634f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 23\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.324049f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 23\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.413176f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 23\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.26462f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 23\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.746334f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 24\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.85251f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 24\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.560282f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 24\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.03707f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 24\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.268227f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 24\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.471123f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 24\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.593208f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 25\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.767986f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 25\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.076988f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 25\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.13642f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 25\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.121529f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 25\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.215782f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 25\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.73236f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 26\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.485447f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 26\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.659838f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 26\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.290493f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 26\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 16.489616f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 26\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.764778f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 26\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.014236f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 27\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.763737f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 27\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.692177f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 27\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.253918f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 27\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.51273f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 27\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.86855f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 27\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.306889f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 28\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.108227f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 28\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.949062f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 28\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.045507f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 28\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.165205f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 28\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 12.919155f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 28\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.903103f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 29\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.889954f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 29\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.677599f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 29\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.235676f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 29\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.818413f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 29\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.454956f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 29\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.443413f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 30\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.767849f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 30\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.12367f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 30\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.95783f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 30\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.690418f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 30\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.498676f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 30\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.116188f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 31\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.376179f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 31\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.445965f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 31\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.826906f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 31\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.523788f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 31\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 16.482994f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 31\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.550964f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 32\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.193125f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 32\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.838432f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 32\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.289452f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 32\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.098053f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 32\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.513762f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 32\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.862543f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 33\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 16.810226f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 33\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.037594f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 33\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.468763f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 33\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.604746f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 33\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.249472f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 33\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.916328f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 34\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.879818f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 34\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.453798f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 34\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.617702f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 34\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.713636f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 34\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.131275f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 34\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.763681f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 35\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.138496f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 35\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.24766f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 35\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.000917f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 35\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.266335f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 35\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.831928f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 35\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.104105f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 36\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.901894f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 36\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.866064f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 36\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.89682f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 36\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.663845f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 36\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.070297f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 36\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.728453f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 37\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.615274f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 37\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.564804f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 37\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.089449f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 37\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.273602f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 37\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.159435f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 37\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.562922f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 38\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.734241f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 38\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.008451f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 38\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 8.860302f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 38\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.15115f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 38\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.32642f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 38\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.513498f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 39\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.381474f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 39\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.2743f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 39\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.010727f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 39\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.264381f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 39\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.826624f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 39\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.921288f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 40\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.755466f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 40\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.364662f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 40\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.126223f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 40\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.64931f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 40\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.564432f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 40\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.728107f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 41\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 17.909348f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 41\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.832344f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 41\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.323364f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 41\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.952206f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 41\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.968285f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 41\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.83363f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 42\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.986597f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 42\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.239515f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 42\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.450031f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 42\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.893978f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 42\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.543922f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 42\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.674696f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 43\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.830986f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 43\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.515713f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 43\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.128778f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 43\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.751575f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 43\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.633709f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 43\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.873392f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 44\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.810955f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 44\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.402004f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 44\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.716564f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 44\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 17.452545f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 44\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 16.890793f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 44\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.448315f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 45\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.888472f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 45\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.899237f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 45\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.195805f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 45\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.420376f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 45\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.594948f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 45\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 9.004853f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 46\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.887007f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 46\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.23485f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 46\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.913727f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 46\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.218992f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 46\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.94302f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 46\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.745415f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 47\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.451485f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 47\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.83382f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 47\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.155079f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 47\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.894794f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 47\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.932127f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 47\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.041811f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 48\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.656693f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 48\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.531162f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 48\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.119312f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 48\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.319973f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 48\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.268059f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 48\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.691246f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 49\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.474157f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 49\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.733646f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 49\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.136124f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 49\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 17.320087f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 49\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.540567f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 49\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.147991f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 50\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.83776f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 50\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.327303f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 50\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.39455f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 50\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.208961f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 50\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.616371f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 50\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.594536f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 51\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.58604f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 51\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.868906f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 51\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.821358f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 51\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.95021f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 51\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.622738f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 51\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.146685f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 52\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.15935f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 52\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.340935f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 52\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.693542f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 52\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.80805f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 52\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.283953f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 52\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.714622f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 53\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.754047f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 53\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.48253f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 53\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.189365f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 53\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.135786f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 53\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.220694f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 53\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.33191f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 54\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.619081f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 54\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.133217f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 54\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.216085f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 54\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.81441f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 54\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.997604f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 54\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.05939f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 55\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 16.644253f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 55\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.239815f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 55\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.43597f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 55\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 16.8848f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 55\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.401718f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 55\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.64897f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 56\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.992f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 56\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.69675f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 56\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.861366f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 56\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.179195f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 56\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = -11.587956f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 56\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.98692f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 57\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.81665f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 57\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.926167f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 57\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.971962f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 57\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.27145f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 57\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.326494f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 57\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.14252f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 58\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.31263f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 58\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.074333f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 58\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.830984f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 58\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.307228f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 58\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.105434f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 58\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.807196f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 59\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.067299f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 59\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.049335f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 59\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.681822f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 59\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.253326f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 59\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 17.409986f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 59\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.683414f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 60\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.863966f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 60\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 15.980584f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 60\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.086948f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 60\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.897078f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 60\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.529032f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 60\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.82579f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 61\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.25418f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 61\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.34762f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 61\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.448723f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 61\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.228636f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 61\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.144558f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 61\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.490255f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 62\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.441963f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 62\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.559408f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 62\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.865923f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 62\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.954279f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 62\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.403667f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 62\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.830547f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 63\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.544434f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 63\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.088642f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 63\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 5.486371f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 63\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.702126f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 63\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.829082f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 63\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.889729f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 64\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.04778f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 64\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.33698f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 64\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.940506f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 64\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.096375f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 64\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.802752f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 64\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.215298f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 65\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.598557f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 65\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.455418f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 65\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.71409f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 65\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.750744f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 65\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.510859f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 65\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.624943f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 66\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.001049f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 66\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.153976f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 66\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.199299f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 66\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.778515f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 66\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.019203f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 66\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.27776f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 67\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.881886f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 67\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.737415f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 67\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.321026f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 67\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.270313f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 67\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.653442f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 67\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.653757f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 68\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.06898f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 68\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.069595f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 68\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.993654f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 68\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.809895f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 68\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.706173f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 68\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.573029f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 69\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.283886f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 69\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.783833f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 69\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.422552f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 69\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.811619f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 69\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.002556f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 69\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.116966f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 70\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.023243f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 70\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.249037f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 70\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.984207f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 70\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.499313f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 70\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.772282f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 70\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.921055f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 71\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.7816f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 71\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.670277f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 71\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.296196f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 71\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.030935f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 71\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.194506f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 71\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.43831f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 72\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.557142f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 72\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.490828f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 72\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.104092f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 72\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.674341f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 72\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.07388f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 72\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.306126f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 73\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.135044f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 73\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.159412f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 73\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.045418f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 73\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.40194f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 73\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.572552f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 73\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.981903f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 74\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.257917f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 74\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.122993f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 74\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.006748f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 74\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.172253f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 74\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.008356f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 74\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.84019f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 75\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.151068f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 75\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.485172f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 75\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.153769f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 75\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.290163f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 75\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.762228f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 75\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.199116f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 76\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 17.930504f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 76\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.04787f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 76\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.809868f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 76\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.353975f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 76\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.562157f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 76\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 16.483915f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 77\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.138283f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 77\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.523014f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 77\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.520844f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 77\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.04196f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 77\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.441517f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 77\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.367897f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 78\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.163624f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 78\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.393862f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 78\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.718964f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 78\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.644243f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 78\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.149078f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 78\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.814312f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 79\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.866508f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 79\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.337425f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 79\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.624027f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 79\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.402237f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 79\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.410057f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 79\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.08833f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 80\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.47953f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 80\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.978199f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 80\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.085361f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 80\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.211655f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 80\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.508362f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 80\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.466614f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 81\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.391834f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 81\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.903198f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 81\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.485249f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 81\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.64059f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 81\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.317387f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 81\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.682806f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 82\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.254333f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 82\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.734877f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 82\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.537487f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 82\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.094929f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 82\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.800623f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 82\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.080275f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 83\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.002201f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 83\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.30722f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 83\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.413658f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 83\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.382023f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 83\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.645979f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 83\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.672878f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 84\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.800962f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 84\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.22847f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 84\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.500309f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 84\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.74908f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 84\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.878939f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 84\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.335938f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 85\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.956377f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 85\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.555515f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 85\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.946405f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 85\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.589813f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 85\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.090248f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 85\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.336586f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 86\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.855642f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 86\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.779556f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 86\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.152008f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 86\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.799198f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 86\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.729807f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 86\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.73042f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 87\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.806095f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 87\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.405361f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 87\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.57449f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 87\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.7407f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 87\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.59734f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 87\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.25967f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 88\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.743744f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 88\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.98431f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 88\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 15.31344f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 88\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.085484f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 88\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.487297f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 88\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.491331f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 89\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 16.660719f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 89\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.529898f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 89\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.550985f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 89\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.375748f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 89\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.937206f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 89\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.631706f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 90\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 17.535595f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 90\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.669437f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 90\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.55685f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 90\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.808851f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 90\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.87554f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 90\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.389326f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 91\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.405817f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 91\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.464638f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 91\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.111252f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 91\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.999516f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 91\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.218391f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 91\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.187355f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 92\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.420967f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 92\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.060745f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 92\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.60073f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 92\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.225628f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 92\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.36546f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 92\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.678913f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 93\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.350622f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 93\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.95152f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 93\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.601427f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 93\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.351856f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 93\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.845188f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 93\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.619637f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 94\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.598852f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 94\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.265049f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 94\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.088186f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 94\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.131905f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 94\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.927309f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 94\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.709093f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 95\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.480736f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 95\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.990673f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 95\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.88835f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 95\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.45876f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 95\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.846493f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 95\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.63565f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 96\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.12495f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 96\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.763638f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 96\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.331306f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 96\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.594742f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 96\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.491268f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 96\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.579607f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 97\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.1447f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 97\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.514366f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 97\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.976524f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 97\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.168167f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 97\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.450222f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 97\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.13343f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 98\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.17472f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 98\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.017311f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 98\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.751623f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 98\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.171782f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 98\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.81949f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 98\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.225515f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 99\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.012215f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 99\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.367924f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 99\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.439997f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 99\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.901167f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 99\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.113953f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 99\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.226475f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 100\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.480293f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 100\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.56205f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 100\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.577469f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 100\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.884739f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 100\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.706923f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 100\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.257725f0\n" + ] + }, + { + "data": { + "text/plain": [ + "EditFlowModel(\n", + " Embedding(22 => 128), \u001b[90m# 2_816 parameters\u001b[39m\n", + " Chain(\n", + " RandomFourierFeatures{Float32, Matrix{Float32}}(Float32[4.107619 -1.6246507 … -3.6645346 -1.3967112]),\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " [\n", + " TransformerBlock(\n", + " Attention(\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " identity,\n", + " identity,\n", + " Onion.var\"#32#34\"(),\n", + " 16,\n", + " 16,\n", + " 8,\n", + " 8,\n", + " ),\n", + " StarGLU(\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(512 => 128; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " NNlib.swish,\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.96080273, 0.93640083, 0.9547064, 0.8971493, 0.95765316, 0.92207366, 0.89724094, 0.9440924, 0.94302225, 0.94956416 … 0.94014513, 0.9212964, 0.91572565, 0.9039559, 0.9231686, 0.9042348, 0.9314332, 0.87426275, 0.8752597, 0.9407146], Float32[-0.025268404, 0.0020312557, -0.010115526, 0.020099802, 0.018506693, 0.0025694135, -0.023937318, -0.038941544, -0.038218282, -0.008356358 … 0.0045030406, 0.029052407, -0.039042093, -0.009993242, 0.003901428, -0.0070870365, -0.037610408, -0.06006574, 0.015338725, 0.011129025], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9615473, 0.97570944, 0.9112915, 0.96853894, 0.9237012, 0.9523371, 0.9733101, 0.9436969, 1.0086424, 0.98759335 … 0.96384525, 0.98503447, 0.9836052, 0.95819885, 0.969784, 0.9607591, 0.9873663, 1.0246212, 0.97779596, 0.963771], Float32[-0.027013712, -0.0054144724, 0.0071041402, -0.015267112, -0.05662798, -0.00019226706, 0.017086789, 0.010009103, 0.004368342, -0.022684177 … 0.008213096, 0.01543913, 0.008588103, -0.042858012, 0.005013047, -0.0087100575, -0.00035417278, -0.0044492367, -3.3963931f-6, -0.0070771035], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " identity,\n", + " ),\n", + " TransformerBlock(\n", + " Attention(\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " identity,\n", + " identity,\n", + " Onion.var\"#32#34\"(),\n", + " 16,\n", + " 16,\n", + " 8,\n", + " 8,\n", + " ),\n", + " StarGLU(\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(512 => 128; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " NNlib.swish,\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.94601697, 0.97375804, 0.9406857, 0.953404, 0.95697165, 0.9183645, 0.93461883, 0.93530893, 0.98690313, 0.92145735 … 0.8612234, 0.87250346, 0.98907375, 0.956685, 0.9498322, 0.9437079, 0.9624967, 0.949929, 0.97197264, 0.97001827], Float32[0.0011167054, -0.014636964, 0.0022019444, 0.0121619, -0.013723163, 0.001547043, 0.011414896, -0.0012122085, -0.006493586, -0.021626603 … 0.069353715, -0.012018405, 0.004048702, 0.004974579, -0.017438088, -0.010104225, -0.009309289, 4.483607f-5, -0.012501754, -0.006304365], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.97332007, 1.0309724, 0.9687911, 0.97576725, 0.96835095, 0.9971229, 0.993208, 0.9710502, 1.003863, 0.9820828 … 0.982708, 0.92708766, 1.0036467, 0.9794132, 0.99849373, 0.9908135, 0.9964946, 1.0093178, 0.9900424, 0.9617081], Float32[-0.016477505, -0.014338043, 0.040039297, -0.029744757, -0.029461078, -0.041657545, 0.027084501, 0.041064046, -0.025039643, 0.0060120723 … 0.0095715625, -0.0138390735, 0.0026735286, -0.050670695, -0.024575308, 0.006731998, -0.007667666, -6.0379556f-5, -0.0033010722, -0.048479233], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " identity,\n", + " ),\n", + " TransformerBlock(\n", + " Attention(\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " identity,\n", + " identity,\n", + " Onion.var\"#32#34\"(),\n", + " 16,\n", + " 16,\n", + " 8,\n", + " 8,\n", + " ),\n", + " StarGLU(\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(512 => 128; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " NNlib.swish,\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.94413495, 0.9591206, 0.9815761, 0.9860674, 0.9643858, 0.99948543, 0.95805496, 0.9728332, 0.9892072, 0.93138975 … 0.92429256, 1.0070444, 0.9443377, 0.9681403, 0.9447193, 0.9323913, 0.9746358, 0.99652237, 0.96340334, 0.97654444], Float32[-0.03537166, -0.006217378, -0.007379122, 0.009719772, -0.0314247, 0.016313963, -0.0015389565, 0.021076221, 0.010470716, -0.02639406 … 0.0006755494, 0.005295955, 0.017049158, -0.0132954335, 0.005307746, 0.02653267, -0.008163272, 0.009826559, 0.030178566, -0.0014013725], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.93666166, 1.0321827, 0.9726321, 0.98780626, 0.9613221, 1.0248475, 1.0161513, 0.96915793, 0.9948018, 1.0429728 … 1.0270013, 1.0185184, 1.0062677, 0.9811149, 1.0302101, 1.0181782, 1.0179951, 1.0333631, 1.0274625, 0.9702701], Float32[-0.06427912, 0.002420664, 0.047289338, -0.034010448, -0.03299984, -0.013876393, 0.023457177, 0.020834371, 0.010680823, -0.032694057 … -0.003318202, -0.0250829, 0.027400794, -0.031808987, -0.024685763, -0.00258377, -0.011304101, -0.01021114, -0.0004895934, -0.020227717], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " identity,\n", + " ),\n", + " TransformerBlock(\n", + " Attention(\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " identity,\n", + " identity,\n", + " Onion.var\"#32#34\"(),\n", + " 16,\n", + " 16,\n", + " 8,\n", + " 8,\n", + " ),\n", + " StarGLU(\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(512 => 128; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " NNlib.swish,\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.98147184, 0.9223102, 1.0042982, 0.97599345, 0.98011535, 0.9964276, 0.9762427, 0.94932944, 0.96026486, 0.95611215 … 0.9575027, 0.9455124, 0.99811995, 0.9754665, 0.9862882, 0.9942666, 0.9694813, 0.96348906, 0.95470506, 0.9039463], Float32[-0.014831864, 9.283005f-5, -0.008477221, 0.040162712, 0.022272639, 0.0436828, -0.009014154, 0.055058725, 0.030263849, -0.040652655 … -0.010325852, -0.023909276, 0.009594226, 0.00861934, -0.0045753345, -0.015833346, 0.019944627, 0.011142825, 0.025711212, 0.026980491], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9566518, 1.0749155, 1.0178746, 1.0410086, 1.0265093, 1.0722593, 1.0385908, 1.0496945, 1.1038729, 1.003326 … 1.0357652, 1.005023, 1.0573806, 1.0052382, 0.98908836, 1.0178303, 1.110416, 1.0397507, 1.0142217, 1.0475482], Float32[-0.08760491, 0.051100586, 0.08073487, -0.080240734, -0.037350997, -0.064348176, 0.01896439, 0.012915793, 0.041853514, -0.02849257 … -0.012428334, -0.040537376, 0.026203565, -0.026402708, -0.039873, -0.0071864277, 0.023559058, -0.015315336, 0.05209827, -0.06641875], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " identity,\n", + " ),\n", + " ],\n", + " Dense(128 => 41; bias=false), \u001b[90m# 5_248 parameters\u001b[39m\n", + " RoPE{Matrix{Float32}}(Float32[1.0 0.5403023 … -0.87528455 -0.065975994; 1.0 0.95041525 … 0.9552474 0.8159282; … ; 1.0 0.9999995 … -0.57972294 -0.5789079; 1.0 0.99999994 … 0.2726629 0.27235872], Float32[0.0 0.84147096 … -0.48360822 -0.9978212; 0.0 0.3109836 … 0.29580808 0.5781532; … ; 0.0 0.0009999999 … -0.8148137 -0.8153929; 0.0 0.0003162278 … 0.9621096 0.9621958]),\n", + " 20,\n", + ") \u001b[90m # Total: 80 trainable arrays, \u001b[39m1_339_392 parameters,\n", + "\u001b[90m # plus 3 non-trainable, 65_600 parameters, summarysize \u001b[39m5.364 MiB." + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model = train_editflow!(P, model; epochs=100, steps_per_epoch=150, batch_size=256, lr=1f-4)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Sampling and Levenshtein plot\n", + "using Random\n", + "n = 1000\n", + "# 100 model samples (final states → strings)\n", + "model_samples_any = sample_gen_n(P, model; n=n, ts=0f0:0.01f0:1f0, rng=Random.MersenneTwister(42))\n", + "model_final_states = map(final_state_from_gen, model_samples_any)\n", + "model_strings = [state_to_PM_string(P, s) for s in model_final_states]\n", + "\n", + "# Build training strings from PM parents (the data PM was built on)\n", + "train_states = [FF.DiscreteState(P.k, sample(PM; rng=Random.MersenneTwister(1000+i))) for i in 1:100]\n", + "train_strings = [state_to_PM_string(P, s) for s in train_states]\n", + "\n", + "# Independent validation strings sampled from PM\n", + "val_states = [FF.DiscreteState(P.k, sample(PM; rng=Random.MersenneTwister(1000+i+2*n))) for i in 1:n]\n", + "val_strings = [state_to_PM_string(P, s) for s in val_states]\n", + "#val_strings = [s for s in val_strings if !(s in train_strings)]\n", + "\n", + "# Plot normalized Levenshtein vs. training set (distinct val/train)\n", + "plt = plot_lev_dist(\"model_vs_true\", val_strings, model_strings, train_strings; title=\"Model vs True (normalized Levenshtein)\")\n", + "display(plt)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model_strings_bos = [\">\" * state_to_PM_string(P, s) for s in model_final_states]\n", + "plt = plot_lev_dist(\"model_vs_true\", val_strings, model_strings_bos, train_strings; title=\"Model vs True (normalized Levenshtein)\")\n", + "display(plt)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "pAA = plot_AA_dist(\"model_vs_true_AA\", val_strings, model_strings; title=\"AA frequency: Natural vs Generated\")\n", + "display(pAA)\n", + "\n", + "pLen = plot_len_dist(\"model_vs_true_len\", val_strings, model_strings; title=\"Length distribution: Natural vs Generated\")\n", + "display(pLen)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Natural 'A' frequency: 0.047142480905978404\n" + ] + } + ], + "source": [ + "println(\"Natural 'A' frequency: \", (isdefined(Main, :val_strings) ? sum(count(==('A'), s) for s in val_strings) / sum(length.(val_strings)) : sum(count(==('A'), s) for s in val_strings) / sum(length.(val_strings))))" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Natural 'A' frequency: 0.04109772423025435\n" + ] + } + ], + "source": [ + "println(\"Natural 'A' frequency: \", (isdefined(Main, :model_strings) ? sum(count(==('A'), s) for s in model_strings) / sum(length.(model_strings)) : sum(count(==('A'), s) for s in model_strings) / sum(length.(model_strings))))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Julia 1.11.6", + "language": "julia", + "name": "julia-1.11" + }, + "language_info": { + "file_extension": ".jl", + "mimetype": "application/julia", + "name": "julia", + "version": "1.11.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/src/editflows.jl b/src/editflows.jl index 3087689..aa551b5 100644 --- a/src/editflows.jl +++ b/src/editflows.jl @@ -1,3 +1,27 @@ +@enum EditFlowImpl::UInt8 begin + GAPWISE + POSITIONWISE + POSITIONWISE_REPARAM +end + +# Coerce user-provided selector to enum +_coerce_impl(x::EditFlowImpl) = x +_coerce_impl(x::Symbol) = _coerce_impl(String(x)) +_coerce_impl(x::AbstractString) = begin + s = lowercase(String(x)) + if s == "gapwise" + return GAPWISE + elseif s == "positionwise" + return POSITIONWISE + elseif s == "positionwise_reparam" + return POSITIONWISE_REPARAM + else + error("Unknown EditFlow implementation: $x") + end +end + +_resolve_impl(impl) = impl === nothing ? GAPWISE : _coerce_impl(impl) + struct EditFlow <: DiscreteProcess k::Int # alphabet size (tokens 1..k) transform::Function # maps unconstrained logits to positive rates @@ -6,15 +30,26 @@ struct EditFlow <: DiscreteProcess padding_token::Int # padding token id used in X1 latent_token::Int # latent placeholder used in Z0 / Zt bos_token::Int # beginning-of-sequence token id (optional, unused by default) + impl::EditFlowImpl # implementation selector end +const EDITFLOW_DISPATCH_STRINGS = ( + "gapwise", + "positionwise", + "positionwise_reparam", +) + EditFlow(k; transform = NNlib.softplus, κ = identity, dκ = t -> one(eltype(t)), padding_token::Int = k + 1, latent_token::Int = k + 2, - bos_token::Int = 0) = - EditFlow(k, transform, κ, dκ, padding_token, latent_token, bos_token) + bos_token::Int = 0, + impl = nothing, # accepts EditFlowImpl | Symbol | String | nothing + ) = begin + impl_enum = _resolve_impl(impl) + EditFlow(k, transform, κ, dκ, padding_token, latent_token, bos_token, impl_enum) +end """ EditFlow_cubic(k; transform=NNlib.softplus, padding_token=k+1, latent_token=k+2, bos_token=0) @@ -28,10 +63,50 @@ Compatible with both scalar and broadcasted usage (the codebase typically calls EditFlow_cubic(k; transform = NNlib.softplus, padding_token::Int = k + 1, latent_token::Int = k + 2, - bos_token::Int = 0) = begin + bos_token::Int = 0, + impl = nothing, + ) = begin κ_cubic(t) = t^3 dκ_cubic(t) = 3 * (t^2) - EditFlow(k, transform, κ_cubic, dκ_cubic, padding_token, latent_token, bos_token) + impl_enum = _resolve_impl(impl) + EditFlow(k, transform, κ_cubic, dκ_cubic, padding_token, latent_token, bos_token, impl_enum) +end + + +EditFlow_alpha(k, alpha::Float32; transform = NNlib.softplus, + padding_token::Int = k + 1, + latent_token::Int = k + 2, + bos_token::Int = 0, + impl = nothing, + ) = begin + κ_alpha(t) = t^alpha + dκ_alpha(t) = alpha * (t^(alpha-1)) + impl_enum = _resolve_impl(impl) + EditFlow(k, transform, κ_alpha, dκ_alpha, padding_token, latent_token, bos_token, impl_enum) +end + +""" + EditFlow_constant(k; C=0.5, eps=1e-3, transform=NNlib.softplus, + padding_token=k+1, latent_token=k+2, bos_token=0) + +Create an `EditFlow` whose scheduler is constant in time: + κ(t) = C (clamped to (eps, 1-eps) for numerical stability) + dκ(t) = 0 + +The definitions are broadcasting-friendly and work for scalars and arrays on CPU/GPU. +""" +EditFlow_constant(k; C=0.5, eps=1e-3, transform = NNlib.softplus, + padding_token::Int = k + 1, + latent_token::Int = k + 2, + bos_token::Int = 0, + impl = nothing, + ) = begin + Cc = clamp(float(C), float(eps), 1.0 - float(eps)) + # Broadcast-friendly closures (scalar or array, CPU/GPU) + κ_const = t -> Cc .+ zero.(t) + dκ_const = t -> zero.(t) + impl_enum = _resolve_impl(impl) + EditFlow(k, transform, κ_const, dκ_const, padding_token, latent_token, bos_token, impl_enum) end @@ -118,6 +193,14 @@ function interpolate_Z_elementwise(P::EditFlow, end function transition_mask_from_Xt(P::EditFlow, Xt::AbstractMatrix{<:Integer}) + if P.impl == GAPWISE + return transition_mask_from_Xt_gapwise(P, Xt) + else + return transition_mask_from_Xt_positionwise(P, Xt) + end +end + +function transition_mask_from_Xt_positionwise(P::EditFlow, Xt::AbstractMatrix{<:Integer}) tokens = P.k pad = P.padding_token xt_len, B = size(Xt) @@ -141,9 +224,8 @@ function transition_mask_from_Xt(P::EditFlow, Xt::AbstractMatrix{<:Integer}) end return T end - # Drop-in replacement (renames ok): now returns (2K+1, L+1, B) -function transition_mask_from_Xt_gapwise(P::EditFlow, Xt::Matrix{Int}) +function transition_mask_from_Xt_gapwise(P::EditFlow, Xt::AbstractMatrix{<:Integer}) K = P.k PAD = P.padding_token BOS = P.bos_token @@ -179,20 +261,54 @@ function transition_mask_from_Xt_gapwise(P::EditFlow, Xt::Matrix{Int}) M[K + t, i, b] = 0f0 # block self-sub to current t end end - - # 3) no ops on padding sites - if Lb < L - M[:, (Lb+1):L, b] .= 0f0 - end - - # 4) (policy) no pre-BOS insert (gap 1) + # 3) (policy) no pre-BOS insert (gap 1) M[1:K, 1, b] .= 0f0 end return M end +function transition_mask_from_Xt_positionwise_reparam(P::EditFlow, Xt::AbstractMatrix{<:Integer}) + tokens = P.k + pad = P.padding_token + xt_len, B = size(Xt) + ins_q_mask = ones(Float32, tokens, xt_len, B) + sub_q_mask = ones(Float32, tokens, xt_len, B) + ins_lambda_mask = ones(Float32, 1, xt_len, B) + sub_lambda_mask = ones(Float32, 1, xt_len, B) + del_lambda_mask = ones(Float32, 1, xt_len, B) + for b in 1:B + x = Xt[:,b] + Lb = count(t -> t != PAD, x) + # Mask the padding + ins_q_mask[:, (Lb+1):xt_len, b] .= 0 + sub_q_mask[:, (Lb+1):xt_len, b] .= 0 + ins_lambda_mask[:, (Lb+1):xt_len, b] .= 0 + sub_lambda_mask[:, (Lb+1):xt_len, b] .= 0 + del_lambda_mask[:, (Lb+1):xt_len, b] .= 0 + #Mask the BOS for sub and del + sub_q_mask[:, 1, b] .= 0 + sub_lambda_mask[:, 1, b] .= 0 + del_lambda_mask[:, 1, b] .= 0 + #Mask the self-substitutions + for i in 2:Lb + t = x[i] + if 1 <= t <= tokens + sub_q_mask[t, i, b] .= 0 + else + throw(ArgumentError("Invalid token: $t")) + end + end + return (ins_q_mask, sub_q_mask, ins_lambda_mask, sub_lambda_mask, del_lambda_mask) +end -# Compute the remaining edits for the EditFlow as a Matrix function remaining_edits(P::EditFlow, Zt::Matrix{Int}, Z1::Matrix{Int}, Xt::Matrix{Int}, dense=false) + if P.impl == GAPWISE + return remaining_edits_gapwise(P, Zt, Z1, Xt) + else + return remaining_edits_positionwise(P, Zt, Z1, Xt) + end +end +# Compute the remaining edits for the EditFlow as a Matrix +function remaining_edits_positionwise(P::EditFlow, Zt::Matrix{Int}, Z1::Matrix{Int}, Xt::Matrix{Int}, dense=false) padding_token = P.padding_token latent_token = P.latent_token tokens = P.k @@ -251,7 +367,7 @@ function remaining_edits(P::EditFlow, Zt::Matrix{Int}, Z1::Matrix{Int}, Xt::Matr end # Drop-in replacement (renames ok): now returns (2K+1, L+1, B) -function remaining_edits_gapwise(P::EditFlow, Zt::Matrix{Int}, Z1::Matrix{Int}, Xt::Matrix{Int}) +function remaining_edits_gapwise(P::EditFlow, Zt::AbstractMatrix{<:Integer}, Z1::AbstractMatrix{<:Integer}, Xt::AbstractMatrix{<:Integer}) K = P.k PAD = P.padding_token LAT = P.latent_token @@ -296,6 +412,74 @@ function remaining_edits_gapwise(P::EditFlow, Zt::Matrix{Int}, Z1::Matrix{Int}, return vcat(ins, sub_pad, del_pad) # (2K+1, L+1, B) end +function remaining_edits_positionwise_reparam(P::EditFlow, Zt::AbstractMatrix{<:Integer}, Z1::AbstractMatrix{<:Integer}, Xt::AbstractMatrix{<:Integer}, dense=false) + padding_token = P.padding_token + latent_token = P.latent_token + tokens = P.k + (_, batch_size) = size(Z1) + + #filtered_cols = [filter(x -> x != latent_token, col) for col in eachcol(Zt)] + #batch_length = maximum(length, filtered_cols) + batch_length = size(Xt, 1) + pos = cumsum((Zt .!= padding_token) .& (Zt .!= latent_token), dims=1) + + #Insert + #inserts = Z1.*(Zt .== latent_token) + inserts = Z1 .* Int64.((Zt .== latent_token) .& (1 .≤ Z1 .≤ tokens)) + insert_edits = zeros(Float32, (tokens, batch_length, batch_size)) + insert_indices = findall(!iszero, inserts) + insert_cols_to_update = pos[insert_indices] + insert_rows_to_update = inserts[insert_indices] + insert_samples_to_update = [idx[2] for idx in insert_indices] + for i in 1:length(insert_rows_to_update) + insert_edits[insert_rows_to_update[i], insert_cols_to_update[i], insert_samples_to_update[i]] += 1 + end + dense_inserts = (insert_rows_to_update, insert_cols_to_update, insert_samples_to_update) + + #Substitution + a = Zt .!= latent_token + b = Z1 .!= latent_token + c = Z1 .!= Zt + subs = Z1.*(a .& b .& c) + sub_edits = zeros(Float32, (tokens, batch_length, batch_size)) + sub_indices = findall(!iszero, subs) + sub_cols_to_update = pos[sub_indices] + sub_rows_to_update = subs[sub_indices] + sub_samples_to_update = [idx[2] for idx in sub_indices] + for i in 1:length(sub_rows_to_update) + sub_edits[sub_rows_to_update[i], sub_cols_to_update[i], sub_samples_to_update[i]] = 1 + end + dense_subs = (sub_rows_to_update .+ tokens, sub_cols_to_update, sub_samples_to_update) + + #Del + dels = Z1 .== latent_token + del_edits = zeros(Float32, (1, batch_length, batch_size)) + del_indices = findall(!iszero, dels) + del_cols_to_update = pos[del_indices] + del_samples_to_update = [idx[2] for idx in del_indices] + for i in 1:length(del_cols_to_update) + del_edits[1, del_cols_to_update[i], del_samples_to_update[i]] = 1 + end + dense_dels = ((2*tokens+1).*ones(Int64, length(del_cols_to_update)), del_cols_to_update, del_samples_to_update) + + if dense == true + return (dense_inserts, dense_subs, dense_dels) + else + return (insert_edits, sub_edits, del_edits) + end +end + + +function step(P::EditFlow, + Xt::DiscreteState{<:AbstractArray{<:Signed}}, + hat, + s1::Real, s2::Real) + if P.impl == GAPWISE + return step_gapwise(P, hat, Xt, s1, s2) + else + return step_positionwise(P, Xt, hat, s1, s2) + end +end @inline function pick_index(w::AbstractVector{<:Real})::Int # treat negatives as zero; assert we have some mass @@ -306,7 +490,8 @@ end return searchsortedfirst(cs, u) # 1..length(w) end -function step(P::EditFlow, + +function step_positionwise(P::EditFlow, Xt::DiscreteState{<:AbstractArray{<:Signed}}, hat, s1::Real, s2::Real) @@ -409,97 +594,6 @@ function part_output(P::EditFlow, M::AbstractArray) return ins, sub, del end - -#= -function edit_loss(P::EditFlow, - M::AbstractArray, - transition_mask::AbstractArray, - edit_multiplier::AbstractArray, - scheduler_scaling; - op_mask=nothing, - eps=1e-8) - R = P.transform(M) - OM = isnothing(op_mask) ? one(eltype(R)) .* ones(eltype(R), size(R)) : op_mask - term1 = sum(transition_mask .* (OM .* R); dims=(1,2)) - scl = reshape(scheduler_scaling, 1, 1, :) - term2 = sum(scl .* edit_multiplier .* log.(R .+ eps); dims=(1,2)) - return mean(term1 .- term2) -end -=# -""" - edit_loss(P::EditFlow, M, transition_mask, edit_multiplier, scheduler_scaling; op_mask=nothing, eps=1e-8) - -Loss matching the reference: mean(sum(transition_mask .* (op_mask .* R)) - sum(scheduler_scaling .* edit_multiplier .* log R)), -where R = transform(M). -Shapes: -- M, transition_mask, edit_multiplier, op_mask: (2K+1, n, B) -- scheduler_scaling: (1, B) or (B,) broadcastable to (1,1,B) -""" -function edit_loss(P::EditFlow, - M, transition_mask, edit_multiplier, scheduler_scaling; - op_mask=nothing, eps=1e-8) - - R = P.transform(M) # must be >= 0 - # (A) Optional op mask to apply symmetrically - OM = isnothing(op_mask) ? one(eltype(R)) : op_mask - - # (B) Sum of valid outgoing rates - term1 = sum(transition_mask .* (OM .* R); dims=(1,2)) - - # (C) Logs only of positive rates (avoid NaN/Inf) - R_logsafe = max.(R, eltype(R)(eps)) # clamp BEFORE log - logR = log.(R_logsafe) - - scl = reshape(scheduler_scaling, 1, 1, :) # (1,1,B) - term2 = sum(scl .* (edit_multiplier .* OM) .* logR; dims=(1,2)) - - return mean(term1 .- term2) -end - - -function edit_loss_gapwise(P::EditFlow, - M, transition_mask, edit_multiplier, scheduler_scaling; - op_mask=nothing, eps=1f-8) - - # 1) transform -> positiva satser - R = P.transform(M) - - # 2) kapa hastigheter för att undvika Inf/NaN i både term1 och log-delen - # (justera RMAX vid behov, 1e3–1e4 funkar ofta bra) - RMAX = 1f3 - R = clamp.(R, eps, RMAX) - - # 3) valfri op-mask - OM = isnothing(op_mask) ? one(eltype(R)) : op_mask - mask = transition_mask .* OM - - # 4) regularizer (sum av giltiga satser) - # -> per-batch summering: 1×1×B - term1 = sum(mask .* R; dims=(1,2)) - - # 5) data-del (log) – log säkert, redan kapat ovan - logR = log.(R) - scl = reshape(scheduler_scaling, 1, 1, :) - term2 = sum(scl .* (edit_multiplier .* OM) .* logR; dims=(1,2)) - - # 6) normalisera med "antal aktiva positioner" för stabil skala - active = sum(mask; dims=(1,2)) - loss_per_batch = (term1 .- term2) ./ (active .+ 1f-8) - - return mean(loss_per_batch) -end - - -""" -getlmask(P::EditFlow, Xt::AbstractMatrix{<:Integer}) - -Build lmask of shape (xt_length, B) from padded Xt. -""" -function getlmask(P::EditFlow, Xt::AbstractMatrix{<:Integer}) - padding_token = P.padding_token - return Xt .!= padding_token -end - # Utility: pick_index over nonnegative weights (1D) @inline function _pick_index1d!(rng::AbstractRNG, cs::AbstractVector{<:Real})::Int s = cs[end] @@ -511,8 +605,8 @@ end # One CTMC Euler step over a single DiscreteState, using gap-wise insertions. function step_gapwise( P::EditFlow, - model, # your EditFlowModel (returns (2K+1, L+1, 1) logits) - Xt::DiscreteState{<:AbstractVector{<:Integer}}, + hat, # your EditFlowModel (returns (2K+1, L+1, 1) logits) + Xt::DiscreteState{<:AbstractVector{<:Signed}}, t1::Real, t2::Real; # times, with dt = t2 - t1 > 0 rng::AbstractRNG = Random.default_rng(), transform::Function = P.transform, @@ -528,8 +622,7 @@ function step_gapwise( Xt_ms = MaskedState(DiscreteState(K, reshape(x, :, 1)), reshape(cmask, :, 1), reshape(lmask, :, 1)) # Model forward (gap-wise head) - M = model([Float32(t1)], Xt_ms) # (2K+1, n+1, 1) logits - R = transform(M) # positive rates + R = transform(hat) # positive rates ins = Array(R[1:K, :, 1]) # (K, n+1) sub = Array(R[K+1:2K, 1:n, 1]) # (K, n) del = vec(Array(R[2K+1, 1:n, 1])) # (n,) @@ -603,7 +696,140 @@ function rollout_gapwise(P::EditFlow, model, x0::DiscreteState, ts::AbstractVect @assert issorted(ts) && first(ts) >= 0 && last(ts) <= 1 x = x0 for k in 1:length(ts)-1 - x = step_gapwise(P, model, x, ts[k], ts[k+1]; rng=rng) + x_tilde = collect(tensor(x)) # Vector{Int} + K = P.k + n = length(x_tilde) + # Build masked state for the model + lmask = trues(n) # all real positions valid + cmask = trues(n) + Xt_ms = MaskedState(DiscreteState(K, reshape(x_tilde, :, 1)), reshape(cmask, :, 1), reshape(lmask, :, 1)) + + hat = model([Float32(ts[k])], Xt_ms) # (2K+1, n+1, 1) logits + x = step_gapwise(P, hat, x, ts[k], ts[k+1]; rng=rng) end return x end + + + +#= +function edit_loss(P::EditFlow, + M::AbstractArray, + transition_mask::AbstractArray, + edit_multiplier::AbstractArray, + scheduler_scaling; + op_mask=nothing, + eps=1e-8) + R = P.transform(M) + OM = isnothing(op_mask) ? one(eltype(R)) .* ones(eltype(R), size(R)) : op_mask + term1 = sum(transition_mask .* (OM .* R); dims=(1,2)) + scl = reshape(scheduler_scaling, 1, 1, :) + term2 = sum(scl .* edit_multiplier .* log.(R .+ eps); dims=(1,2)) + return mean(term1 .- term2) +end +=# + + +function edit_loss(P::EditFlow, M, transition_mask, edit_multiplier, scheduler_scaling; op_mask=nothing, eps=1e-8) + if P.impl == GAPWISE + return edit_loss_gapwise(P, M, transition_mask, edit_multiplier, scheduler_scaling; op_mask=op_mask, eps=eps) + elseif P.impl == POSITIONWISE + return edit_loss_positionwise(P, M, transition_mask, edit_multiplier, scheduler_scaling; op_mask=op_mask, eps=eps) + elseif P.impl == POSITIONWISE_REPARAM + return edit_loss_positionwise_reparam(P, M, transition_mask, edit_multiplier, scheduler_scaling; op_mask=op_mask, eps=eps) + end +end + +""" + edit_loss(P::EditFlow, M, transition_mask, edit_multiplier, scheduler_scaling; op_mask=nothing, eps=1e-8) + +Loss matching the reference: mean(sum(transition_mask .* (op_mask .* R)) - sum(scheduler_scaling .* edit_multiplier .* log R)), +where R = transform(M). +Shapes: +- M, transition_mask, edit_multiplier, op_mask: (2K+1, n, B) +- scheduler_scaling: (1, B) or (B,) broadcastable to (1,1,B) +""" +function edit_loss_positionwise(P::EditFlow, + M, transition_mask, edit_multiplier, scheduler_scaling; + op_mask=nothing, eps=1e-8) + + R = P.transform(M) # must be >= 0 + # (A) Optional op mask to apply symmetrically + OM = isnothing(op_mask) ? one(eltype(R)) : op_mask + + # (B) Sum of valid outgoing rates + term1 = sum(transition_mask .* (OM .* R); dims=(1,2)) + + # (C) Logs only of positive rates (avoid NaN/Inf) + R_logsafe = max.(R, eltype(R)(eps)) # clamp BEFORE log + logR = log.(R_logsafe) + + scl = reshape(scheduler_scaling, 1, 1, :) # (1,1,B) + term2 = sum(scl .* (edit_multiplier .* OM) .* logR; dims=(1,2)) + + return mean(term1 .- term2) +end + + +function edit_loss_gapwise(P::EditFlow, + M, transition_mask, edit_multiplier, scheduler_scaling; + op_mask=nothing, eps=1f-8) + + # 1) transform -> positiva satser + R = P.transform(M) + + # 2) kapa hastigheter för att undvika Inf/NaN i både term1 och log-delen + # (justera RMAX vid behov, 1e3–1e4 funkar ofta bra) + RMAX = 1f3 + R = clamp.(R, eps, RMAX) + + # 3) valfri op-mask + OM = isnothing(op_mask) ? one(eltype(R)) : op_mask + mask = transition_mask .* OM + + # 4) regularizer (sum av giltiga satser) + # -> per-batch summering: 1×1×B + term1 = sum(mask .* R; dims=(1,2)) + + # 5) data-del (log) – log säkert, redan kapat ovan + logR = log.(R) + scl = reshape(scheduler_scaling, 1, 1, :) + term2 = sum(scl .* (edit_multiplier .* OM) .* logR; dims=(1,2)) + + # 6) normalisera med "antal aktiva positioner" för stabil skala + active = sum(mask; dims=(1,2)) + loss_per_batch = (term1 .- term2) ./ (active .+ 1f-8) + + return mean(loss_per_batch) +end + +function edit_loss_positionwise_reparam(P::EditFlow, + M, transition_mask, edit_multiplier, scheduler_scaling; eps=1e-8) + (ins_q_mask, sub_q_mask, ins_lambda_mask, sub_lambda_mask, del_lambda_mask) = transition_mask + (ins_q, sub_q, ins_lambda, sub_lambda, del_lambda) = M + ins_q = softmax(ins_q, dims=1) + sub_q = softmax(sub_q, dims=1) + ins_lambda = P.transform(ins_q) + sub_lambda = P.transform(sub_q) + del_lambda = P.transform(del_lambda) + loss_term_1 = sum(ins_lambda.* ins_lambda_mask + sub_lambda.* sub_lambda_mask + del_lambda.* del_lambda_mask) + scl = reshape(scheduler_scaling, 1, 1, :) # (1,1,B) + + #hmm fix shape of lambdas they might be vectors... + ins_rate_log = log.(max.(ins_lambda.* ins_q, eltype(ins_lambda)(eps))) + sub_rate_log = log.(max.(sub_lambda .* sub_q, eltype(R)(eps))) + del_rate_log = log.(max.(del_lambda, eltype(R)(eps))) + + (ins_q_edits, sub_q_edits, del_lambda_edits) = edit_multiplier + loss_term_2 = sum( (ins_q_edits .* ins_q_log) + () ) +end +""" +getlmask(P::EditFlow, Xt::AbstractMatrix{<:Integer}) + +Build lmask of shape (xt_length, B) from padded Xt. +""" +function getlmask(P::EditFlow, Xt::AbstractMatrix{<:Integer}) + padding_token = P.padding_token + return Xt .!= padding_token +end + From 08f64958251997c4514a6fb4f3ca9da944d0c1c0 Mon Sep 17 00:00:00 2001 From: Glowster Date: Fri, 14 Nov 2025 14:02:06 +0100 Subject: [PATCH 8/9] probably found the bug --- editflow_code/analysis_notebook copy 2.ipynb | 3051 ++++++++++++++ editflow_code/analysis_notebook copy.ipynb | 3982 +++++++++++++++--- editflow_code/analysis_notebook.ipynb | 2532 ++++++----- editflow_code/gapwise_editflowsrun.jl | 2 +- src/editflows.jl | 380 +- 5 files changed, 7941 insertions(+), 2006 deletions(-) create mode 100644 editflow_code/analysis_notebook copy 2.ipynb diff --git a/editflow_code/analysis_notebook copy 2.ipynb b/editflow_code/analysis_notebook copy 2.ipynb new file mode 100644 index 0000000..532ad3a --- /dev/null +++ b/editflow_code/analysis_notebook copy 2.ipynb @@ -0,0 +1,3051 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m\u001b[1m Activating\u001b[22m\u001b[39m project at `~/dev/Flowfusion.jl/editflow_code`\n", + "\u001b[92m\u001b[1mPrecompiling\u001b[22m\u001b[39m project...\n", + " 2645.6 ms\u001b[33m ✓ \u001b[39mFlowfusion\n", + " 1 dependency successfully precompiled in 4 seconds. 470 already precompiled.\n", + " \u001b[33m1\u001b[39m dependency precompiled but a different version is currently loaded. Restart julia to access the new version. Otherwise, loading dependents of this package may trigger further precompilation to work with the unexpected version.\n", + "\u001b[32m\u001b[1m Resolving\u001b[22m\u001b[39m package versions...\n", + "\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `~/dev/Flowfusion.jl/editflow_code/Project.toml`\n", + "\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `~/dev/Flowfusion.jl/editflow_code/Manifest.toml`\n", + "WARNING: redefinition of constant Main.AA20. This may fail, cause incorrect answers, or produce other errors.\n", + "WARNING: redefinition of constant Main.TOK2ID_AA. This may fail, cause incorrect answers, or produce other errors.\n", + "WARNING: redefinition of constant Main.PM. This may fail, cause incorrect answers, or produce other errors.\n" + ] + }, + { + "data": { + "text/plain": [ + "plot_len_dist (generic function with 1 method)" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using Pkg\n", + "Pkg.activate(@__DIR__)\n", + "Pkg.instantiate()\n", + "using Revise\n", + "\n", + "using Random\n", + "using Statistics\n", + "using Adapt\n", + "using Functors\n", + "using Flux\n", + "using Onion\n", + "using RandomFeatureMaps\n", + "using Zygote\n", + "\n", + "Pkg.develop(path=joinpath(@__DIR__, \"..\"))\n", + "using Flowfusion\n", + "const FF = Flowfusion\n", + "\n", + "include(joinpath(@__DIR__, \"prob_model.jl\"))\n", + "include(joinpath(@__DIR__, \"helper_funcs.jl\"))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "to_same_device (generic function with 1 method)" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import CUDA\n", + "\n", + "# Device helpers\n", + "const _gpu_enabled = try\n", + " CUDA.has_cuda()\n", + "catch\n", + " false\n", + "end\n", + "\n", + "to_dev(x) = _gpu_enabled ? Adapt.adapt(CUDA.CuArray, x) : x\n", + "to_cpu(x) = _gpu_enabled ? Adapt.adapt(Array, x) : x\n", + "# move x to the same device type as y (Array or CuArray)\n", + "to_same_device(x, y) = (_gpu_enabled && (y isa CUDA.CuArray)) ? Adapt.adapt(CUDA.CuArray, x) : Adapt.adapt(Array, x)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "make_minibatch (generic function with 1 method)" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Minibatch builder (uses true PM)\n", + "function make_minibatch(B::Int, P::FF.EditFlow; rng=Random.default_rng())\n", + " K = P.k\n", + " x0s = Vector{FF.DiscreteState}(undef, B)\n", + " x1s = Vector{FF.DiscreteState}(undef, B)\n", + " for b in 1:B\n", + " # x1 from true PM\n", + " seq1 = sample(PM; rng=rng)\n", + " @assert all(1 .<= seq1 .<= K)\n", + " x1s[b] = FF.DiscreteState(K, seq1)\n", + " # x0: uniform tokens with random length in 1:10 (no BOS in x0)\n", + " L0 = rand(rng, 1:10)\n", + " seq0 = rand(rng, 1:K, L0)\n", + " x0s[b] = FF.DiscreteState(K, seq0)\n", + " end\n", + " ts = rand(rng, Float32, B)\n", + " return x0s, x1s, ts\n", + "end\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "EditFlowModel" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Model definition\n", + "struct EditFlowModel{L}\n", + " layers::L\n", + "end\n", + "Flux.@layer EditFlowModel\n", + "#=\n", + "function EditFlowModel(; d=128, num_heads=8, nlayers=6, rff_dim=128, cond_dim=128, K::Int)\n", + " embedding = Flux.Embedding(K + 2 => d)\n", + " time_embed = Flux.Chain(RandomFourierFeatures(1 => rff_dim, 1.0f0), Dense(rff_dim => cond_dim))\n", + " blocks = [Onion.AdaTransformerBlock(d, cond_dim, num_heads) for _ in 1:nlayers]\n", + " head_combined = Dense(d => 2K + 1, bias=false)\n", + " rope = RoPE(d ÷ num_heads, 4096)\n", + " return EditFlowModel((; embedding, time_embed, blocks, head_combined, rope, K))\n", + "end\n", + "=#\n", + "function EditFlowModel(; d=128, num_heads=8, nlayers=6, rff_dim=128, cond_dim=128, K::Int)\n", + " embedding = Flux.Embedding(K + 2 => d)\n", + " time_embed = Flux.Chain(RandomFourierFeatures(1 => rff_dim, 1.0f0), Dense(rff_dim => cond_dim))\n", + " blocks = [Onion.AdaTransformerBlock(d, cond_dim, num_heads) for _ in 1:nlayers]\n", + " ins_q = Dense(d => K, bias=false)\n", + " sub_q = Dense(d => K, bias=false)\n", + " ins_lambda = Dense(d => 1, bias=false)\n", + " sub_lambda = Dense(d => 1, bias=false)\n", + " del_lambda = Dense(d => 1, bias=false)\n", + " rope = RoPE(d ÷ num_heads, 4096)\n", + " return EditFlowModel((; embedding, time_embed, blocks, ins_q, sub_q, ins_lambda, sub_lambda, del_lambda, rope, K))\n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "# Forward pass\n", + "function (model::EditFlowModel)(t, Xt_ms)\n", + " m = model.layers\n", + " X = FF.tensor(Xt_ms)\n", + " X = ndims(X) == 1 ? reshape(X, :, 1) : X\n", + " L, B = size(X)\n", + "\n", + " pmask = Zygote.@ignore FF.getlmask(Xt_ms)\n", + " Xp = X .+ 1\n", + " #println(\"min/max X: \", minimum(X), \" / \", maximum(X), \" pad=\", P.padding_token, \" lat=\", P.latent_token)\n", + " if maximum(X) > P.padding_token\n", + " error(\"X contains values greater than the padding token; illegal token values in input\")\n", + " end\n", + "\n", + " H = m.embedding(Xp)\n", + "\n", + " t = ndims(t) == 0 ? fill(Float32(t), B) : Float32.(t)\n", + " cond = m.time_embed(reshape(t, 1, B))\n", + "\n", + " cond = to_same_device(cond, H)\n", + " pmask = Zygote.@ignore to_same_device(pmask, H)\n", + " rope = Zygote.@ignore to_same_device(m.rope[1:L], H)\n", + "\n", + " for blk in m.blocks\n", + " H = blk(H; cond, rope, kpad_mask=pmask)\n", + " end\n", + "\n", + " ins_head = m.ins_q(H)\n", + " sub_head = m.sub_q(H)\n", + " lambda_ins = m.ins_lambda(H)\n", + " lambda_sub = m.sub_lambda(H)\n", + " lambda_del = m.del_lambda(H)\n", + " return (ins_head, sub_head, lambda_ins, lambda_sub, lambda_del)\n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "# Forward pass\n", + "# function (model::EditFlowModel)(t, Xt_ms)\n", + "# m = model.layers\n", + "# X = FF.tensor(Xt_ms)\n", + "# X = ndims(X) == 1 ? reshape(X, :, 1) : X\n", + "# L, B = size(X)\n", + "\n", + "# pmask = Zygote.@ignore FF.getlmask(Xt_ms)\n", + "# Xp = X .+ 1\n", + "# #println(\"min/max X: \", minimum(X), \" / \", maximum(X), \" pad=\", P.padding_token, \" lat=\", P.latent_token)\n", + "# #@assert all((0 .<= X) .& (X .<= P.padding_token))\n", + "# mX = Zygote.@ignore maximum(X)\n", + "# nX = Zygote.@ignore minimum(X)\n", + "# @assert (0 <= nX) && (mX <= P.padding_token)\n", + "\n", + " \n", + "# H = m.embedding(Xp)\n", + "\n", + "# t = ndims(t) == 0 ? fill(Float32(t), B) : Float32.(t)\n", + "# cond = m.time_embed(reshape(t, 1, B))\n", + "\n", + "# cond = to_same_device(cond, H)\n", + "# pmask = Zygote.@ignore to_same_device(pmask, H)\n", + "# rope = Zygote.@ignore to_same_device(m.rope[1:L], H)\n", + "\n", + "# for blk in m.blocks\n", + "# H = blk(H; cond, rope, kpad_mask=pmask)\n", + "# end\n", + "# return m.head_combined(H)\n", + "# end\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "train_editflow! (generic function with 1 method)" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Training (GPU if available)\n", + "function train_editflow!(P::FF.EditFlow,\n", + " model;\n", + " epochs::Int=1,\n", + " steps_per_epoch::Int=100,\n", + " batch_size::Int=64,\n", + " lr::Float32=1f-2,\n", + " seed::Int=42,\n", + " print_every::Int=25)\n", + "\n", + " rng = Random.MersenneTwister(seed)\n", + " Random.seed!(seed)\n", + "\n", + " # Move model to device (GPU if available)\n", + " model = Functors.fmap(to_dev, model)\n", + " opt_state = Flux.setup(Flux.Adam(lr), model)\n", + "\n", + " for epoch in 1:epochs\n", + " for step in 1:steps_per_epoch\n", + "\n", + " # 1) Minibatch Sampling\n", + " x0s, x1s, ts = make_minibatch(batch_size, P; rng=rng)\n", + "\n", + " # 2) Align and batch\n", + " Z0, Z1 = FF.align_and_batch(P, x0s, x1s)\n", + "\n", + " # 3) Interpolate\n", + " Zt, Xt = FF.interpolate_Z_elementwise(P, Z0, Z1, ts)\n", + "\n", + " # 4) Prepend BOS\n", + " bos = P.bos_token\n", + " Zt = vcat(fill(bos, 1, batch_size), Zt)\n", + " Xt = vcat(fill(bos, 1, batch_size), Xt)\n", + " Z1 = vcat(fill(bos, 1, batch_size), Z1)\n", + " \n", + " # 5) Masks and multipliers\n", + " transition_mask = FF.transition_mask_from_Xt(P, Xt)\n", + " edit_multiplier = FF.remaining_edits(P, Zt, Z1, Xt)\n", + " #@assert size(transition_mask) == size(edit_multiplier)\n", + "\n", + " # 6) Scheduler scaling\n", + " den = 1f0 .- P.κ.(ts)\n", + " den = max.(den, 1f-3)\n", + " scheduler_scaling = P.dκ.(ts) ./ den\n", + "\n", + " # 7) Masked state\n", + " lmask = Xt .!= P.padding_token\n", + " cmask = trues(size(lmask))\n", + " Xt_ms = FF.MaskedState(FF.DiscreteState(P.k, Xt), cmask, lmask)\n", + "\n", + " ts_d = to_dev(ts)\n", + " Xt_ms_d = to_dev(Xt_ms)\n", + " Tmask_d = to_dev(transition_mask)\n", + " Emult_d = to_dev(edit_multiplier)\n", + " sched_d = to_dev(reshape(Float32.(scheduler_scaling), 1, 1, :))\n", + "\n", + " # 8) Forward + loss + update\n", + " loss, grad = Flux.withgradient(model) do m\n", + " M = m(ts_d, Xt_ms_d)\n", + " l = FF.edit_loss(P, M, Tmask_d, Emult_d, sched_d; eps=1f-8)\n", + " if isnan(l)\n", + " println(\"Maximum element of M: \", maximum(M))\n", + " end\n", + " l\n", + " end\n", + " Flux.update!(opt_state, model, grad[1])\n", + "\n", + " if step % print_every == 0\n", + " @info \"train\" epoch step loss=Float32(loss)\n", + " end\n", + " end\n", + " end\n", + "\n", + " return Functors.fmap(to_cpu, model)\n", + "end\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "# Init process and model\n", + "K = PM.K\n", + "P = FF.EditFlow(K; bos_token=0, impl=\"positionwise_reparam\")\n", + "model = EditFlowModel(; d=128, num_heads=8, nlayers=4, rff_dim=128, cond_dim=128, K=K)\n", + "nothing" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.972092f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.547047f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.814123f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.86299f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.428902f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.44519f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.755375f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.63697f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.66145f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.980005f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.676495f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.823967f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.604435f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.628433f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.269749f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.370718f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.981895f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.29564f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.05313f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.661705f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.352457f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.975006f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.44165f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.114304f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.830158f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.29099f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.880302f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.773508f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.42518f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.253447f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.465221f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.716324f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.315796f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.590342f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.11945f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.802334f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.715399f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.133106f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.506771f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.31068f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.549904f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.21441f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.020954f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.809784f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.816322f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 11.10005f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.037218f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.556658f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.747284f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.18045f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.459362f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.183155f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.935974f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.975842f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.257816f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.16243f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.237125f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.72068f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.045029f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.03865f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 11\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.980974f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 11\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.974388f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 11\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.994131f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 11\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.29249f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 11\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.863419f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 11\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.127146f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 12\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.681866f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 12\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.440746f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 12\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.46564f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 12\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.074389f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 12\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.455484f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 12\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.068605f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 13\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.59634f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 13\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.282074f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 13\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.803133f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 13\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.92038f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 13\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.747942f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 13\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.94925f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 14\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.425396f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 14\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.448444f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 14\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.657696f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 14\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.587557f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 14\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.831514f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 14\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.390194f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 15\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.020035f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 15\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.410772f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 15\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.76912f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 15\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.478642f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 15\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.846231f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 15\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.842266f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 16\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.358135f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 16\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.717499f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 16\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.117746f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 16\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.582458f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 16\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.147333f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 16\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.345675f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 17\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.380396f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 17\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.366549f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 17\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.646837f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 17\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.5616f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 17\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.525606f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 17\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.963268f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 18\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.720358f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 18\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.79974f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 18\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.13392f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 18\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.455585f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 18\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.213562f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 18\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.929577f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 19\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.667606f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 19\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.59198f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 19\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.14951f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 19\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.727703f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 19\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.535524f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 19\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.531374f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 20\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.03439f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 20\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.629353f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 20\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.897205f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 20\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.220057f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 20\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.027626f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 20\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.112152f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 21\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.379562f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 21\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.807442f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 21\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.60457f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 21\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.335194f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 21\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.965631f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 21\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.327007f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 22\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.268284f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 22\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.73925f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 22\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.675303f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 22\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.893906f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 22\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.89526f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 22\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.98605f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 23\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.154684f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 23\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.895681f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 23\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.107021f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 23\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.837322f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 23\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.70697f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 23\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.26533f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 24\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.145313f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 24\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.1321f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 24\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.53107f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 24\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.040863f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 24\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.176334f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 24\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.094204f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 25\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.033104f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 25\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.512857f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 25\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.793964f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 25\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.60687f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 25\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.829811f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 25\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.069487f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 26\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 17.734646f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 26\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.18549f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 26\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.256248f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 26\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.401571f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 26\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.009022f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 26\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.209995f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 27\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.12656f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 27\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.539986f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 27\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.397396f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 27\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.079025f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 27\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.479889f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 27\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.610525f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 28\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.227245f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 28\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.67744f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 28\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.710548f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 28\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.983185f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 28\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.211796f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 28\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.314728f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 29\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.877901f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 29\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.496384f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 29\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.785358f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 29\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.737282f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 29\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.9102f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 29\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.662106f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 30\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 16.906403f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 30\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.716015f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 30\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.618082f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 30\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.765678f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 30\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.711426f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 30\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.011974f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 31\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.7238f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 31\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.592659f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 31\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.709558f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 31\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.07872f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 31\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.348526f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 31\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.064106f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 32\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.897255f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 32\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.324472f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 32\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.630274f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 32\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.075851f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 32\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.555912f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 32\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.24704f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 33\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.994556f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 33\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.781471f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 33\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.19625f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 33\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.328653f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 33\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.941914f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 33\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.934614f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 34\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.049961f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 34\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.934216f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 34\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.771145f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 34\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.813606f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 34\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.86628f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 34\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.586544f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 35\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.481121f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 35\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.066532f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 35\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.385017f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 35\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.676384f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 35\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.874306f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 35\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.355312f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 36\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.09821f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 36\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.159306f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 36\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.657879f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 36\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.845825f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 36\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.372375f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 36\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.752993f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 37\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.873785f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 37\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.484112f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 37\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.912094f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 37\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.653551f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 37\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.556973f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 37\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.944939f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 38\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.665516f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 38\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.347084f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 38\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.694008f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 38\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.613409f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 38\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.544956f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 38\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.902126f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 39\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.099602f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 39\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.433033f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 39\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.63831f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 39\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.330196f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 39\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.579561f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 39\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.511242f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 40\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.326582f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 40\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.177572f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 40\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.340986f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 40\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.477205f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 40\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.986431f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 40\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.133919f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 41\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.872013f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 41\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.14673f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 41\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.704659f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 41\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.198008f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 41\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.918495f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 41\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.065418f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 42\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.116703f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 42\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.001947f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 42\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.781761f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 42\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.540459f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 42\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.281252f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 42\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.846443f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 43\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.743122f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 43\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.816837f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 43\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.741148f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 43\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.262049f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 43\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.01141f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 43\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.787575f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 44\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.283468f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 44\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.458675f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 44\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.277485f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 44\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.03348f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 44\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.936434f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 44\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.165476f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 45\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.269474f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 45\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.315693f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 45\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.033718f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 45\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.826042f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 45\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.53991f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 45\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.090122f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 46\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.082125f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 46\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.51723f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 46\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.586445f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 46\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.018702f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 46\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.69442f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 46\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.83265f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 47\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.189922f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 47\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.178204f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 47\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.848724f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 47\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.149426f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 47\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.197594f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 47\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.3241f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 48\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.188025f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 48\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.411463f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 48\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.432335f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 48\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.71156f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 48\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.088894f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 48\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.21531f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 49\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.149452f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 49\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.175003f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 49\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.178764f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 49\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.635054f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 49\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.653725f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 49\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.785437f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 50\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.671728f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 50\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.6824f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 50\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.098778f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 50\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.858032f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 50\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.040945f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 50\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.54076f0\n" + ] + }, + { + "data": { + "text/plain": [ + "EditFlowModel(\n", + " Embedding(22 => 128), \u001b[90m# 2_816 parameters\u001b[39m\n", + " Chain(\n", + " RandomFourierFeatures{Float32, Matrix{Float32}}(Float32[-4.5109034 -3.5286963 … 9.479959 7.8329725]),\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " [\n", + " TransformerBlock(\n", + " Attention(\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " identity,\n", + " identity,\n", + " Onion.var\"#32#34\"(),\n", + " 16,\n", + " 16,\n", + " 8,\n", + " 8,\n", + " ),\n", + " StarGLU(\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(512 => 128; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " NNlib.swish,\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9967958, 0.9869625, 0.99037206, 0.9952497, 0.9702036, 0.9800837, 0.9745326, 0.9878916, 0.9594757, 0.9897762 … 0.9973829, 0.98189306, 0.99930227, 0.9924687, 0.96413124, 0.98626226, 0.98451954, 0.99558693, 0.98469424, 0.9983752], Float32[-0.0005225724, 0.008076679, -0.004573487, -0.008991586, -0.0022569797, 0.00772917, 0.022327727, 0.0013664486, -0.006174539, 0.00085590524 … -0.0055099158, 0.0036732075, -0.001059735, 0.012229179, -0.00652443, 0.000418949, 0.0061954665, 0.0028194247, -0.0041092695, 0.00022841303], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.98412365, 0.98356694, 0.9991844, 0.98061776, 1.0074458, 1.0001413, 0.98833823, 0.9987704, 0.991204, 0.99532646 … 0.9848799, 1.0059643, 0.98044896, 0.98279643, 1.0155826, 0.9848778, 0.9933505, 0.9947882, 0.9984975, 0.99049044], Float32[0.0103082, 0.010853426, -7.58663f-5, 0.009344174, 0.004389455, -0.0016753467, 0.0062471745, -0.0046117036, -0.016211234, 0.015867772 … -0.012600643, -0.0019048655, 0.0023564878, 0.008244524, -0.00075314543, 0.0050747017, -0.006136866, -0.0053728544, -0.0018225668, 0.023820948], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " identity,\n", + " ),\n", + " TransformerBlock(\n", + " Attention(\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " identity,\n", + " identity,\n", + " Onion.var\"#32#34\"(),\n", + " 16,\n", + " 16,\n", + " 8,\n", + " 8,\n", + " ),\n", + " StarGLU(\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(512 => 128; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " NNlib.swish,\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.99398494, 0.99072254, 0.98964727, 0.9913998, 0.96825975, 0.9956356, 0.9806926, 0.9927313, 0.9783374, 1.0013367 … 0.9955111, 0.9714232, 0.9932761, 0.9916518, 0.97599345, 0.99484235, 0.9863062, 0.9868813, 0.99386036, 0.9897667], Float32[0.002271547, 0.0012500598, -0.0013109404, -0.009307533, -0.005532772, 0.00332578, -0.0062586013, -0.004487046, -0.009959927, -0.001968619 … -0.0092587015, 0.0016701458, 0.004358063, -0.0034356923, 0.008127138, -0.0012910413, 0.01754202, 0.01152308, -0.0062666866, 0.011563656], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[1.0095794, 1.0033473, 1.0020524, 1.0036801, 1.0157589, 1.0096356, 1.0005842, 1.0092266, 0.9975341, 0.98216057 … 1.0134289, 0.9880383, 1.0035987, 1.0086101, 1.008442, 1.0066518, 1.0115547, 1.0150577, 0.9883698, 1.0045927], Float32[0.0018625382, 0.0074362713, 0.010829576, 0.00023766467, -0.009477628, -0.005826937, -0.001142101, -0.016898308, -0.012365104, 0.01040461 … -0.0031639615, -0.008584582, -0.012951189, 0.0051505445, -0.0012443908, 0.008775254, 0.002358304, 7.299369f-5, -0.0044311574, 0.01911879], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " identity,\n", + " ),\n", + " TransformerBlock(\n", + " Attention(\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " identity,\n", + " identity,\n", + " Onion.var\"#32#34\"(),\n", + " 16,\n", + " 16,\n", + " 8,\n", + " 8,\n", + " ),\n", + " StarGLU(\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(512 => 128; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " NNlib.swish,\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9964801, 0.9907213, 0.9829918, 0.9904836, 1.0075997, 0.9931966, 0.967814, 0.994991, 0.99343467, 0.9698302 … 1.0127897, 0.98682904, 0.9882866, 0.9758389, 0.9728117, 1.0221164, 0.97261125, 0.9949346, 1.0151469, 0.99335915], Float32[-0.014417081, 0.006284324, -0.009420766, 0.0028740377, -0.007851509, -0.0016916802, 0.00028211612, 0.004104854, -0.0010160299, 0.0028311377 … 0.0061248355, -0.003470834, 0.0037332277, -0.00510081, 0.00078595727, -0.0052126795, 0.0049999044, -0.007494009, -0.0076053017, -0.0034516104], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.98102707, 0.9881729, 1.0145462, 1.0161818, 1.010741, 1.0101572, 1.0054857, 0.9960153, 1.0076207, 0.9982568 … 1.0110102, 0.97780424, 1.0103778, 1.0270656, 1.0007466, 1.0155469, 1.0250667, 0.9943188, 1.0158885, 0.9926699], Float32[-0.020408258, -0.007663947, -0.002164433, 0.0045097587, -0.004046006, -0.0084987385, -0.0032783668, -0.0019530786, -0.0018806072, 0.0014927586 … 0.002657746, -0.004882839, -0.0094046, 0.0029575205, -0.010758868, 0.005579408, -0.00012946833, -0.0011488283, -0.0051159984, 0.012121034], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " identity,\n", + " ),\n", + " TransformerBlock(\n", + " Attention(\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " Dense(128 => 128; bias=false), \u001b[90m# 16_384 parameters\u001b[39m\n", + " identity,\n", + " identity,\n", + " Onion.var\"#32#34\"(),\n", + " 16,\n", + " 16,\n", + " 8,\n", + " 8,\n", + " ),\n", + " StarGLU(\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(512 => 128; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " Dense(128 => 512; bias=false), \u001b[90m# 65_536 parameters\u001b[39m\n", + " NNlib.swish,\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.97678447, 0.9843075, 0.97703946, 1.0089988, 0.9998969, 0.99314827, 1.005877, 0.9890229, 0.98229724, 0.9969458 … 0.9900987, 0.99567735, 0.9876625, 0.99173796, 1.0165083, 0.9832781, 0.9971774, 1.0104102, 0.9998328, 0.99126804], Float32[-0.0036148801, -0.0061858366, 0.0043971017, 0.0063074683, 0.005699646, 0.0021153758, -0.0040238057, 0.005645371, 0.001263952, 0.009946144 … -0.0067127184, -0.0050887824, -0.0009767002, -0.016533986, 0.011165631, -0.00066996843, 0.0014427631, -0.007045365, -0.0015280164, -0.0040101036], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " AdaLN(\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[1.0210867, 1.0158178, 1.0208023, 1.047025, 1.0237092, 1.018517, 1.0044487, 0.9989978, 0.99009013, 1.0100825 … 1.01286, 1.0051826, 1.0109634, 1.0528429, 1.0127131, 1.0134708, 1.0189143, 0.9862647, 1.0223742, 0.98723614], Float32[-0.0045142854, -0.008482742, -0.0018320186, 0.0036619315, -0.010827755, -0.0021696852, -0.010647439, -0.0046669086, -0.007829798, 0.005749223 … -0.005271609, -0.015943931, 0.00100527, -0.01039895, -0.005209468, 0.00091932324, 0.0036592623, 0.009832175, -0.005363889, 0.01747159], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", + " ),\n", + " identity,\n", + " ),\n", + " ],\n", + " Dense(128 => 20; bias=false), \u001b[90m# 2_560 parameters\u001b[39m\n", + " Dense(128 => 20; bias=false), \u001b[90m# 2_560 parameters\u001b[39m\n", + " Dense(128 => 1; bias=false), \u001b[90m# 128 parameters\u001b[39m\n", + " Dense(128 => 1; bias=false), \u001b[90m# 128 parameters\u001b[39m\n", + " Dense(128 => 1; bias=false), \u001b[90m# 128 parameters\u001b[39m\n", + " RoPE{Matrix{Float32}}(Float32[1.0 0.5403023 … -0.87528455 -0.065975994; 1.0 0.95041525 … 0.9552474 0.8159282; … ; 1.0 0.9999995 … -0.57972294 -0.5789079; 1.0 0.99999994 … 0.2726629 0.27235872], Float32[0.0 0.84147096 … -0.48360822 -0.9978212; 0.0 0.3109836 … 0.29580808 0.5781532; … ; 0.0 0.0009999999 … -0.8148137 -0.8153929; 0.0 0.0003162278 … 0.9621096 0.9621958]),\n", + " 20,\n", + ") \u001b[90m # Total: 84 trainable arrays, \u001b[39m1_339_648 parameters,\n", + "\u001b[90m # plus 3 non-trainable, 65_600 parameters, summarysize \u001b[39m5.365 MiB." + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model = train_editflow!(P, model; epochs=50, steps_per_epoch=150, batch_size=256, lr=1f-4)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "MersenneTwister(42)" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rng=Random.MersenneTwister(42)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "10-element Vector{String}:\n", + " \"EVQLVEWGGGLVQPVRS\"\n", + " \"QVQLVKSGSPLKKPGADKV\"\n", + " \"QVQLVESGGGLVKCG\"\n", + " \"QMQLQESGPGLVKPGASVK\"\n", + " \"EVQEVGGGLVQPGGLSLSL\"\n", + " \"EVTL\"\n", + " \"QVQLVESGGGVVQPGRSGA\"\n", + " \"EVQLVQKGGL\"\n", + " \"NTLQESSGVGLV\"\n", + " \"EVYVVEHGGGL\"" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model_samples_any = sample_gen_n(P, model; n=10, ts=0f0:0.01f0:1f0, rng)\n", + "model_final_states = map(final_state_from_gen, model_samples_any)\n", + "model_strings = [state_to_PM_string(P, s) for s in model_final_states]" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "10-element Vector{String}:\n", + " \"EVQLVESGGGLVKPPGQLR\"\n", + " \"QVQLVQSKAEVKKPGASVKV\"\n", + " \"EGQRVECGGGGGQRG\"\n", + " \"EVQLVESGGGLV\"\n", + " \"QVQLVQSGAAV\"\n", + " \"EVQLVESGGGLVQPGGSLTL\"\n", + " \"QVQLVESGGGVVQPCR\"\n", + " \"QVLLVQSGTEVFKPGASMKV\"\n", + " \"QVLLVQSTAEVKK\"\n", + " \"QITLKESDPTLVKP\"" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_states = [FF.DiscreteState(P.k, sample(PM; rng=rng)) for i in 1:10]\n", + "train_strings = [state_to_PM_string(P, s) for s in train_states]" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1000-element Vector{String}:\n", + " \"EVLHVVEGGG\"\n", + " \"QVQLVQSGAEAK\"\n", + " \"QVQLQESGPGLAKPSEVLSLV\"\n", + " \"EVQLVESGGGLVKPGHSLR\"\n", + " \"QVQLVKTGMEVKKPGASVK\"\n", + " \"QVQLQESTPGLVKPSVSETL\"\n", + " \"QVQLVQSGAAVKTPGASV\"\n", + " \"EVQLVESGGGLV\"\n", + " \"QVQLVQSGGALV\"\n", + " \"MVMLVPSGAEVKKP\"\n", + " \"QVQLVRSGQALVK\"\n", + " \"QVQLVQSGAAV\"\n", + " \"QKQLLQSGGVLVKPSTLSL\"\n", + " ⋮\n", + " \"EVQLVESCSGGLVKPGGGS\"\n", + " \"QVQHVQSGAEYKKPGASK\"\n", + " \"QVQLVQSDAEV\"\n", + " \"QVQLVQSGAEVEQP\"\n", + " \"QNLKQPSGAEVKV\"\n", + " \"QVQLVKSGAGLVKPGASVKV\"\n", + " \"QVQLVQYGQGNVKKPGASVRT\"\n", + " \"QVQLVYSGAEVK\"\n", + " \"QVLLVESGGGVVQTGAS\"\n", + " \"QVQLVQSGHAEVKRPGA\"\n", + " \"QVQLQQSGPAEVKPKPCSL\"\n", + " \"QLQLVQSGAEVKK\"" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Sampling and Levenshtein plot\n", + "using Random\n", + "n = 1000\n", + "# 100 model samples (final states → strings)\n", + "model_samples_any = sample_gen_n(P, model; n=n, ts=0f0:0.01f0:1f0, rng=rng)\n", + "model_final_states = map(final_state_from_gen, model_samples_any)\n", + "model_strings = [state_to_PM_string(P, s) for s in model_final_states]\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32mProgress: 100%|█████████████████████████████████████████| Time: 0:00:00\u001b[39m\n" + ] + }, + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "m = 1000\n", + "p=100000\n", + "# Build training strings from PM parents (the data PM was built on)\n", + "train_states = [FF.DiscreteState(P.k, sample(PM; rng=rng)) for i in 1:m]\n", + "train_strings = [state_to_PM_string(P, s) for s in train_states]\n", + "\n", + "# Independent validation strings sampled from PM\n", + "val_states = [FF.DiscreteState(P.k, sample(PM; rng=rng)) for i in 1:p]\n", + "val_strings = [state_to_PM_string(P, s) for s in val_states]\n", + "#val_strings = [s for s in val_strings if !(s in train_strings)]\n", + "\n", + "# Plot normalized Levenshtein vs. training set (distinct val/train)\n", + "plt = plot_lev_dist(\"model_vs_true\", val_strings, model_strings, train_strings; title=\"Model vs True (normalized Levenshtein)\")\n", + "display(plt)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32mProgress: 100%|█████████████████████████████████████████| Time: 0:00:00\u001b[39m\n" + ] + }, + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model_strings_bos = [\">\" * state_to_PM_string(P, s) for s in model_final_states]\n", + "plt = plot_lev_dist(\"model_vs_true\", val_strings, model_strings_bos, train_strings; title=\"Model vs True (normalized Levenshtein)\")\n", + "display(plt)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "n=1000000\n", + "val_states = [FF.DiscreteState(P.k, sample(PM; rng)) for i in 1:n]\n", + "val_strings = [state_to_PM_string(P, s) for s in val_states]\n", + "\n", + "\n", + "\n", + "pLen = plot_len_dist(\"model_vs_true_len\", val_strings, model_strings; title=\"Length distribution: Natural vs Generated\")\n", + "display(pLen)\n", + "\n", + "pAA = plot_AA_dist(\"model_vs_true_AA\", val_strings, model_strings; title=\"AA frequency: Natural vs Generated\")\n", + "display(pAA)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Natural 'A' frequency: 0.047142480905978404\n" + ] + } + ], + "source": [ + "println(\"Natural 'A' frequency: \", (isdefined(Main, :val_strings) ? sum(count(==('A'), s) for s in val_strings) / sum(length.(val_strings)) : sum(count(==('A'), s) for s in val_strings) / sum(length.(val_strings))))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Natural 'A' frequency: 0.04109772423025435\n" + ] + } + ], + "source": [ + "println(\"Natural 'A' frequency: \", (isdefined(Main, :model_strings) ? sum(count(==('A'), s) for s in model_strings) / sum(length.(model_strings)) : sum(count(==('A'), s) for s in model_strings) / sum(length.(model_strings))))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "MersenneTwister(42)" + ] + }, + "execution_count": 183, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rng = Random.MersenneTwister(42)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "" + ] + }, + "execution_count": 226, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "n=1000000\n", + "val_states = [FF.DiscreteState(P.k, sample(PM; rng)) for i in 1:n]\n", + "val_strings = [state_to_PM_string(P, s) for s in val_states]\n", + "pLen = plot_len_dist(\"model_vs_true_len\", val_strings, val_strings; title=\"Length distribution: Natural vs Generated\")\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Julia 1.11.6", + "language": "julia", + "name": "julia-1.11" + }, + "language_info": { + "file_extension": ".jl", + "mimetype": "application/julia", + "name": "julia", + "version": "1.11.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/editflow_code/analysis_notebook copy.ipynb b/editflow_code/analysis_notebook copy.ipynb index 166565f..67c138b 100644 --- a/editflow_code/analysis_notebook copy.ipynb +++ b/editflow_code/analysis_notebook copy.ipynb @@ -10,9 +10,6 @@ "output_type": "stream", "text": [ "\u001b[32m\u001b[1m Activating\u001b[22m\u001b[39m project at `~/dev/Flowfusion.jl/editflow_code`\n", - "\u001b[92m\u001b[1mPrecompiling\u001b[22m\u001b[39m project...\n", - " 2280.2 ms\u001b[32m ✓ \u001b[39mFlowfusion\n", - " 1 dependency successfully precompiled in 4 seconds. 470 already precompiled.\n", "\u001b[32m\u001b[1m Resolving\u001b[22m\u001b[39m package versions...\n", "\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `~/dev/Flowfusion.jl/editflow_code/Project.toml`\n", "\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `~/dev/Flowfusion.jl/editflow_code/Manifest.toml`\n", @@ -124,7 +121,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -158,20 +155,19 @@ " embedding = Flux.Embedding(K + 2 => d)\n", " time_embed = Flux.Chain(RandomFourierFeatures(1 => rff_dim, 1.0f0), Dense(rff_dim => cond_dim))\n", " blocks = [Onion.AdaTransformerBlock(d, cond_dim, num_heads) for _ in 1:nlayers]\n", - " head_combined = Dense(d => 2K + 1, bias=false)\n", " ins_q = Dense(d => K, bias=false)\n", " sub_q = Dense(d => K, bias=false)\n", " ins_lambda = Dense(d => 1, bias=false)\n", " sub_lambda = Dense(d => 1, bias=false)\n", " del_lambda = Dense(d => 1, bias=false)\n", " rope = RoPE(d ÷ num_heads, 4096)\n", - " return EditFlowModel((; embedding, time_embed, blocks, head_combined, rope, K))\n", + " return EditFlowModel((; embedding, time_embed, blocks, ins_q, sub_q, ins_lambda, sub_lambda, del_lambda, rope, K))\n", "end" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -184,9 +180,11 @@ "\n", " pmask = Zygote.@ignore FF.getlmask(Xt_ms)\n", " Xp = X .+ 1\n", - " println(\"min/max X: \", minimum(X), \" / \", maximum(X), \" pad=\", P.padding_token, \" lat=\", P.latent_token)\n", - " @assert all((0 .<= X) .& (X .<= P.padding_token))\n", - " \n", + " #println(\"min/max X: \", minimum(X), \" / \", maximum(X), \" pad=\", P.padding_token, \" lat=\", P.latent_token)\n", + " if maximum(X) > P.padding_token\n", + " error(\"X contains values greater than the padding token; illegal token values in input\")\n", + " end\n", + "\n", " H = m.embedding(Xp)\n", "\n", " t = ndims(t) == 0 ? fill(Float32(t), B) : Float32.(t)\n", @@ -211,45 +209,45 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "# Forward pass\n", - "function (model::EditFlowModel)(t, Xt_ms)\n", - " m = model.layers\n", - " X = FF.tensor(Xt_ms)\n", - " X = ndims(X) == 1 ? reshape(X, :, 1) : X\n", - " L, B = size(X)\n", + "# function (model::EditFlowModel)(t, Xt_ms)\n", + "# m = model.layers\n", + "# X = FF.tensor(Xt_ms)\n", + "# X = ndims(X) == 1 ? reshape(X, :, 1) : X\n", + "# L, B = size(X)\n", "\n", - " pmask = Zygote.@ignore FF.getlmask(Xt_ms)\n", - " Xp = X .+ 1\n", - " #println(\"min/max X: \", minimum(X), \" / \", maximum(X), \" pad=\", P.padding_token, \" lat=\", P.latent_token)\n", - " #@assert all((0 .<= X) .& (X .<= P.padding_token))\n", - " mX = Zygote.@ignore maximum(X)\n", - " nX = Zygote.@ignore minimum(X)\n", - " @assert (0 <= nX) && (mX <= P.padding_token)\n", + "# pmask = Zygote.@ignore FF.getlmask(Xt_ms)\n", + "# Xp = X .+ 1\n", + "# #println(\"min/max X: \", minimum(X), \" / \", maximum(X), \" pad=\", P.padding_token, \" lat=\", P.latent_token)\n", + "# #@assert all((0 .<= X) .& (X .<= P.padding_token))\n", + "# mX = Zygote.@ignore maximum(X)\n", + "# nX = Zygote.@ignore minimum(X)\n", + "# @assert (0 <= nX) && (mX <= P.padding_token)\n", "\n", " \n", - " H = m.embedding(Xp)\n", + "# H = m.embedding(Xp)\n", "\n", - " t = ndims(t) == 0 ? fill(Float32(t), B) : Float32.(t)\n", - " cond = m.time_embed(reshape(t, 1, B))\n", + "# t = ndims(t) == 0 ? fill(Float32(t), B) : Float32.(t)\n", + "# cond = m.time_embed(reshape(t, 1, B))\n", "\n", - " cond = to_same_device(cond, H)\n", - " pmask = Zygote.@ignore to_same_device(pmask, H)\n", - " rope = Zygote.@ignore to_same_device(m.rope[1:L], H)\n", + "# cond = to_same_device(cond, H)\n", + "# pmask = Zygote.@ignore to_same_device(pmask, H)\n", + "# rope = Zygote.@ignore to_same_device(m.rope[1:L], H)\n", "\n", - " for blk in m.blocks\n", - " H = blk(H; cond, rope, kpad_mask=pmask)\n", - " end\n", - " return m.head_combined(H)\n", - "end\n" + "# for blk in m.blocks\n", + "# H = blk(H; cond, rope, kpad_mask=pmask)\n", + "# end\n", + "# return m.head_combined(H)\n", + "# end\n" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -258,7 +256,7 @@ "train_editflow! (generic function with 1 method)" ] }, - "execution_count": 6, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -302,7 +300,7 @@ " # 5) Masks and multipliers\n", " transition_mask = FF.transition_mask_from_Xt(P, Xt)\n", " edit_multiplier = FF.remaining_edits(P, Zt, Z1, Xt)\n", - " @assert size(transition_mask) == size(edit_multiplier)\n", + " #@assert size(transition_mask) == size(edit_multiplier)\n", "\n", " # 6) Scheduler scaling\n", " den = 1f0 .- P.κ.(ts)\n", @@ -349,14 +347,14 @@ "source": [ "# Init process and model\n", "K = PM.K\n", - "P = FF.EditFlow(K; bos_token=0, impl=\"positionwise\")\n", + "P = FF.EditFlow(K; bos_token=0, impl=\"positionwise_reparam\")\n", "model = EditFlowModel(; d=128, num_heads=8, nlayers=4, rff_dim=128, cond_dim=128, K=K)\n", "nothing" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -364,125 +362,2405 @@ "output_type": "stream", "text": [ "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 82.07346f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 62.159813f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 54.437492f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 52.70323f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 46.34868f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 47.708572f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 46.801437f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 43.88524f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 46.17478f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 46.61335f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 44.934906f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 41.69713f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 45.287468f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 43.52704f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 39.66895f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 39.165527f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 40.31173f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 36.59504f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 40.564255f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 37.86731f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 40.385826f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 40.322083f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 39.391945f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 34.939816f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 35.111343f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 35.31593f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 37.190735f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 36.458412f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 39.276863f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 38.577705f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 37.672207f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.816956f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 35.438004f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 36.36937f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.889923f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 34.536453f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 34.919273f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.35535f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 34.92321f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 37.54946f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.466896f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 36.90836f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 36.573483f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.769262f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 34.593307f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.809368f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 34.314964f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 34.868347f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.30793f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 35.449608f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.058853f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.30246f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 35.396187f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.03281f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.141605f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 34.48079f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.728176f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.799397f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 34.22338f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.56803f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 11\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.286154f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 11\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.165651f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 11\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.54279f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 11\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.8528f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 11\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.07912f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 11\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.126358f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 12\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 34.789497f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 12\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.40204f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 12\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.934967f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 12\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.35504f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 12\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 34.06865f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 12\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.93891f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 13\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.98565f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 13\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.669083f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 13\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.357887f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 13\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.41867f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 13\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.702007f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 13\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.948685f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 14\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.02884f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 14\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.43153f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 14\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.269884f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 14\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.48836f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 14\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.304775f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 14\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.295242f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 15\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.564354f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 15\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.63555f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 15\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.694923f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 15\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.10176f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 15\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.823997f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 15\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.046465f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 16\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.151978f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 16\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.241508f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 16\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.599903f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 16\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.371204f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 16\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.115711f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 16\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.063667f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 17\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.288649f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 17\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.17442f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 17\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.832388f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 17\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.63764f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 17\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.523653f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 17\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.578972f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 18\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.127888f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 18\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.43596f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 18\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.935762f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 18\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.834002f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 18\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.114868f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 18\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.446186f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 19\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.983818f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 19\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.701529f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 19\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.964905f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 19\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.798264f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 19\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.764925f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 19\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.253445f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 20\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.058111f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 20\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.854343f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 20\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.131287f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 20\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.974604f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 20\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.332983f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 20\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.150225f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 21\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.560247f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 21\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.277634f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 21\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.871674f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 21\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.280323f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 21\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.3564f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 21\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.779842f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 22\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.763954f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 22\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.29353f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 22\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.820616f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 22\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.870682f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 22\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.851711f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 22\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.26233f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 23\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.022175f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 23\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.356493f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 23\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.398968f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 23\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.326962f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 23\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.917953f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 23\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.692986f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 24\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.146017f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 24\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.466309f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 24\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.152166f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 24\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.562721f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 24\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.2849f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 24\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.194546f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 25\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.014896f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 25\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.774408f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 25\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.552523f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 25\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.040781f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 25\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.373951f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 25\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.159891f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 26\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.581429f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 26\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.509647f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 26\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.619043f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 26\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.09383f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 26\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.292168f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 26\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.818909f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 27\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.22113f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 27\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.000816f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 27\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.185415f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 27\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.700916f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 27\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.716354f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 27\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.38358f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 28\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.860315f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 28\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.69223f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 28\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.02826f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 28\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.024052f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 28\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.986008f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 28\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.56084f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 29\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.256157f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 29\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.557503f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 29\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.805897f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 29\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.765497f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 29\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.463768f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 29\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.466944f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 30\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.504349f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 30\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.668938f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 30\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.541996f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 30\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.095675f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 30\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.885004f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 30\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.725517f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 31\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.679646f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 31\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.332363f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 31\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.44205f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 31\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.786064f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 31\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.905752f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 31\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.435757f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 32\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.278011f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 32\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.903355f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 32\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.621813f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 32\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.800285f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 32\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.840708f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 32\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.018559f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 33\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.744186f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 33\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.735939f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 33\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.753193f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 33\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.21335f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 33\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.902012f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 33\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.089495f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 34\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.58031f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 34\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.263393f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 34\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.389595f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 34\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.411808f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 34\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.020435f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 34\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.144455f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 35\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.2962f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 35\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.897776f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 35\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.124271f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 35\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.111145f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 35\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.478966f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 35\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.792439f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 36\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.627457f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 36\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.22819f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 36\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.252316f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 36\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.160707f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 36\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.44091f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 36\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.25015f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 37\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.912188f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 37\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.750805f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 37\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.955189f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 37\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.026106f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 37\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.814238f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 37\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.040257f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 38\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.69309f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 38\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.04459f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 38\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.733395f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 38\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.58453f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 38\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.76516f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 38\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.80672f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 39\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.192831f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 39\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.523682f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 39\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.81498f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 39\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.908417f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 39\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.202335f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 39\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.47245f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 40\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.739391f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 40\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.068176f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 40\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.204624f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 40\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.831722f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 40\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.325375f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 40\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.1208f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 41\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.505514f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 41\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.5488f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 41\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.15102f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 41\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.176058f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 41\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.531853f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 41\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.99091f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 42\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.7192f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 42\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.728962f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 42\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.610317f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 42\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.416164f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 42\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.267582f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 42\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.809444f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 43\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.121967f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 43\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.335537f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 43\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.019642f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 43\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.637943f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 43\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.238605f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 43\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.979734f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 44\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.764843f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 44\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.702675f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 44\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.530308f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 44\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.94001f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 44\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.980862f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 44\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.945194f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 45\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.208347f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 45\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.52969f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 45\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.940765f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 45\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.146969f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 45\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.750103f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 45\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.741966f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 46\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.725286f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 46\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.318342f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 46\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.266163f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 46\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.628586f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 46\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.748112f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 46\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.119446f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 47\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.42128f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 47\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.901266f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 47\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.349586f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 47\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.926575f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 47\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.67647f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 47\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.600336f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 48\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.054993f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 48\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.485657f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 48\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.708344f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 48\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.638538f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 48\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.087189f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 48\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.382866f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 49\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.803917f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 49\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.354397f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 49\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.697845f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 49\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.903067f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 49\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.217096f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 49\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.466969f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 50\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.123995f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 50\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.66383f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 50\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.066828f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 50\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.641502f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 50\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.865017f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 50\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.352922f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 51\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.092247f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 51\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.752254f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 51\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.05304f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 51\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.390366f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 51\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.090763f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 51\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.176765f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 52\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.52108f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 52\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.761932f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 52\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.511892f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 52\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.29064f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 52\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.123562f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 52\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.654358f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 53\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.53424f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 53\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.85925f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 53\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.881779f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 53\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.724129f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 53\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.388699f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 53\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.270184f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 54\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.898977f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 54\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.655685f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 54\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.33598f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 54\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.403103f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 54\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.912945f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 54\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.995174f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 55\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.486912f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 55\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.728872f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 55\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.981642f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 55\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.466846f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 55\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.494558f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 55\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.157269f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 56\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.891315f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 56\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.81565f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 56\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.700804f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 56\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.016748f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 56\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 12.17991f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 56\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.762886f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 57\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.146517f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 57\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.501875f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 57\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.152218f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 57\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.110748f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 57\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.041103f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 57\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.101912f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 58\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.75323f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 58\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.365854f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 58\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.630274f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 58\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.837723f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 58\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.288212f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 58\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.135359f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 59\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.50134f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 59\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.57468f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 59\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.161716f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 59\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.87622f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 59\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.94062f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 59\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.8095f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 60\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.677917f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 60\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.46408f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 60\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.636616f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 60\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.922928f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 60\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.925663f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 60\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.531475f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 61\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.56285f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 61\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.698103f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 61\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.562912f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 61\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.336823f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 61\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.004013f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 61\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.274128f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 62\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.192417f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 62\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.432222f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 62\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.7392f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 62\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.985062f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 62\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.17378f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 62\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.799166f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 63\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.425634f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 63\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.468296f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 63\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = -5.995845f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 63\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.998158f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 63\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.038448f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 63\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.033749f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 64\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.00533f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 64\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.06829f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 64\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.032722f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 64\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.024298f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 64\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.170773f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 64\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.376472f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 65\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.3689f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 65\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.082571f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 65\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.11168f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 65\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.405136f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 65\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.619356f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 65\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.924015f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 66\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.195768f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 66\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.6123f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 66\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.629646f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 66\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.263647f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 66\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.222168f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 66\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.27013f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 67\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.022396f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 67\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.813812f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 67\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.486214f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 67\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.982243f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 67\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.693348f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 67\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.587395f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 68\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.629896f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 68\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.485079f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 68\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.933212f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 68\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.13412f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 68\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.339632f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 68\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.508022f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 69\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.1389f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 69\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.179682f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 69\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.82854f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 69\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.925406f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 69\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.995193f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 69\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.171566f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 70\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.341312f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 70\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.789955f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 70\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.980728f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 70\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.528828f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 70\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.014193f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 70\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.833584f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 71\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.698025f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 71\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.143219f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 71\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.284584f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 71\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.312044f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 71\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.3766f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 71\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.132614f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 72\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.464508f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 72\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.122822f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 72\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.225592f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 72\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.98212f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 72\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.111795f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 72\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.57614f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 73\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.375362f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 73\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.394024f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 73\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.27369f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 73\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.573868f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 73\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.740505f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 73\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.441765f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 74\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.771257f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 74\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.316023f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 74\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.580448f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 74\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.979656f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 74\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.400307f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 74\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.783073f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 75\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.628641f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 75\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.261189f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 75\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.686115f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 75\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.199797f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 75\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.52521f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 75\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.92347f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 76\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.527836f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 76\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.664387f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 76\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.153656f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 76\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.139687f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 76\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.865797f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 76\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.617004f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 77\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.611313f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 77\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.56675f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 77\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.861835f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 77\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.752243f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 77\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.810802f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 77\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.026962f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 78\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.86181f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 78\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.10205f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 78\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.015896f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 78\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.185467f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 78\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.688988f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 78\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.525013f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 79\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.49948f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 79\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.364954f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 79\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.283792f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 79\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.86265f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 79\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.039726f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 79\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.208265f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 80\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.437443f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 80\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.15319f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 80\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.790619f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 80\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.035023f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 80\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.27858f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 80\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.90172f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 81\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.833107f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 81\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.40643f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 81\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.92462f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 81\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.017815f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 81\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.769001f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 81\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.803432f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 82\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.338768f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 82\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.840986f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 82\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.032543f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 82\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.793646f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 82\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.137222f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 82\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.951649f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 83\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.809486f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 83\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.11989f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 83\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.108162f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 83\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.218895f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 83\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.576492f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 83\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.534967f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 84\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.878292f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 84\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.561852f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 84\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.066605f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 84\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.652271f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 84\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.827291f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 84\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.628416f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 85\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.40998f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 85\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.966393f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 85\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.59112f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 85\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.124773f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 85\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.860865f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 85\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.764847f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 86\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.170559f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 86\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.344856f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 86\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.094692f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 86\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.650303f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 86\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.443104f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 86\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.755693f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 87\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.28392f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 87\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.591637f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 87\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.558187f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 87\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.37761f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 87\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.453766f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 87\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.134775f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 88\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.580048f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 88\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.17911f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 88\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.458458f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 88\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.700092f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 88\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.836933f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 88\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.738186f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 89\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.815561f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 89\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.215977f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 89\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.129654f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 89\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.794102f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 89\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.125484f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 89\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.227345f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 90\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 81.5171f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.045433f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 90\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 63.493782f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.293316f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 90\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 59.012363f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.518925f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 90\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 58.97118f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.422106f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 90\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 50.419544f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.499228f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 90\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 51.323597f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.184135f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 91\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 51.624657f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.26989f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 91\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 48.713852f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.96262f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 91\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 49.294586f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.837223f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 91\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 52.53109f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.046673f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 91\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 46.66154f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.653591f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 91\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 46.56837f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.075289f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 92\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 49.605583f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.342976f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 92\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 47.38654f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.946255f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 92\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 44.482132f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.191769f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 92\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 48.082584f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.609737f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 92\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 45.253014f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 17.93655f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 92\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 43.067787f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.087547f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 93\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 42.395924f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.67813f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 93\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 42.587074f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.700335f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 93\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 41.693085f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.010113f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 93\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 42.755257f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.786858f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 93\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 43.976986f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.679712f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 93\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 40.780937f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.27972f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 94\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 42.15659f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.283361f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 94\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 39.584618f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.018883f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 94\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 40.946358f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.054487f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 94\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 42.274662f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.607964f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 94\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 41.849945f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.42205f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 94\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.083143f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 95\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.265385f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 95\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.279564f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 95\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.667408f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 95\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.51435f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 95\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.896326f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 95\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.182985f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 96\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.115044f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 96\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.596788f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 96\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.342295f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 96\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.938116f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 96\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.91387f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 96\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 41.614258f0\n" + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.638369f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 97\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.230114f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 97\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.580563f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 97\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.14f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 97\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.359524f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 97\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.14893f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 97\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.068623f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 98\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.713148f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 98\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.837017f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 98\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.895924f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 98\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.283958f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 98\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.11446f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 98\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.290411f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 99\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.527283f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 99\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.730885f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 99\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.029686f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 99\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.297504f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 99\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.37918f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 99\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.384432f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 100\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.19099f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 100\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.480999f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 100\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.165169f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 100\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.805332f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 100\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.753227f0\n", + "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 100\n", + "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.786406f0\n" ] }, { @@ -491,7 +2769,7 @@ "EditFlowModel(\n", " Embedding(22 => 128), \u001b[90m# 2_816 parameters\u001b[39m\n", " Chain(\n", - " RandomFourierFeatures{Float32, Matrix{Float32}}(Float32[8.529786 1.4104536 … 0.28503644 -7.469009]),\n", + " RandomFourierFeatures{Float32, Matrix{Float32}}(Float32[7.531563 7.089197 … 2.0401998 3.328936]),\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " ),\n", " [\n", @@ -516,12 +2794,12 @@ " NNlib.swish,\n", " ),\n", " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9927389, 0.995017, 0.99550515, 0.9944197, 0.9924084, 0.9989874, 0.99385405, 0.9942679, 1.0000424, 1.0037912 … 0.9942788, 0.99082935, 0.9904582, 0.9915918, 0.9994775, 0.99774563, 0.99622786, 0.99355125, 0.98682874, 0.9916295], Float32[-0.0058128564, -0.0014852639, 0.0017711775, 0.0025712461, -0.0038710728, 0.0016847431, 0.0028967822, 0.003991662, -0.0015246351, -4.6463974f-5 … 0.0006014786, -0.0023472367, -0.0023561758, 0.0006260582, 0.0022964154, 0.0005220497, -0.0015367864, -0.0010421762, -0.0013536707, -0.000992959], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9836579, 0.9530255, 0.9908016, 0.96244663, 0.99054164, 0.98432475, 0.9993702, 0.97146636, 0.9746882, 0.97592133 … 0.96757305, 0.98850816, 0.9889486, 0.9910423, 0.9700498, 0.9524227, 0.9703022, 0.9919154, 0.9982276, 0.98223925], Float32[-0.0059723244, -0.026827456, -0.005359013, 0.005184757, -0.015056814, 0.0036728473, -0.00411119, 0.014544279, -0.013788157, -0.0062612076 … -0.008408193, 0.007813087, 0.0057916404, -0.002667083, -0.0019434843, 0.0012296549, 0.0013133418, 0.0023761056, 0.00048080317, 0.006975226], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " ),\n", " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9972253, 0.99951667, 0.9969008, 0.9992949, 0.98925614, 0.9973548, 0.9966963, 1.0072627, 1.0053163, 0.99864525 … 1.0076041, 0.9989389, 0.99891305, 0.9896608, 0.9973922, 1.0018995, 0.9994337, 1.0012733, 1.0044928, 0.99932957], Float32[-0.0020217572, 0.00045662682, 0.0037664024, 0.0031012846, -0.0027788132, -0.0036462964, 0.0027171317, 0.0037337039, -0.0019016194, 0.001187094 … 0.0007999025, 0.0010091417, -0.0004998848, -0.00046192663, -0.0009970615, 0.0010046392, -0.0013360388, -0.00071286794, -0.0017081661, -0.0023509015], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9946981, 0.9968043, 0.98153776, 0.9809628, 0.99675304, 0.93618464, 0.9842954, 0.9745212, 1.0101839, 1.0036527 … 1.0099263, 0.99696696, 0.9861587, 0.9825586, 0.9812812, 0.97964483, 0.98476547, 0.98760384, 0.9870029, 0.979692], Float32[0.006245078, 0.00454478, -0.015628312, 0.006516256, -0.009261778, -0.01909565, 0.005845533, 0.008189242, -0.00068665465, 0.0016260961 … -0.0041808817, -0.00029761743, 0.0026925767, -0.007287982, -0.01596789, 0.00494587, -0.00235075, -0.0046186335, 0.0087447725, -0.0045568403], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " ),\n", @@ -548,12 +2826,12 @@ " NNlib.swish,\n", " ),\n", " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9937645, 0.9900202, 1.0001692, 0.99522585, 0.9978626, 0.9951527, 0.9973957, 0.99491405, 0.9904468, 0.99554497 … 0.9967526, 0.9979659, 0.99347985, 0.9954838, 0.99880844, 0.99987525, 0.9969922, 0.9964722, 1.0026605, 0.9961422], Float32[-0.0030214672, -0.00076218136, 0.0021669136, -0.000539773, -0.00023664715, -0.0012380814, 0.00011221414, -0.0050113825, -0.00034657144, 0.002786954 … 0.0015049657, -0.0019077003, -0.0015806447, 0.0021096128, -0.0047903364, 0.0013625681, -0.001690899, 0.0019822896, -0.0033150173, 0.0020150973], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.97298455, 0.9863549, 0.9892886, 0.9950389, 0.9884353, 0.9859241, 0.94629824, 0.9905537, 0.997098, 0.9910578 … 0.98902434, 0.9732674, 0.993341, 0.98686963, 0.97267485, 0.9891902, 0.9939604, 0.98106074, 0.989807, 0.9971157], Float32[0.0012234193, 0.0013402402, -0.0051020766, -0.0023925323, 0.0024530701, -0.007705464, 0.027468415, -0.0025647462, -0.0012954248, -0.0012756804 … -0.0062676566, -0.004466568, -0.005843617, -0.0037935532, -0.0069217044, -0.0014938526, 0.0044353334, -0.0068317032, -0.001554352, -0.006626264], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " ),\n", " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.99748296, 1.0048722, 0.99336493, 1.001614, 0.9965636, 0.99819463, 0.99690235, 1.0005269, 0.9995311, 0.9954543 … 0.99206907, 1.0004294, 1.0084617, 1.0007285, 1.0030751, 1.0050168, 1.0015122, 1.0002509, 0.9992035, 0.9950786], Float32[-0.00090104516, -0.0003761406, -0.0008079005, 0.0015836438, -0.0008108232, 0.0013318892, 0.0005486783, -0.002771887, 0.0011146952, 0.0041731894 … -0.0013222725, -0.0013798344, -0.0010058298, 0.0017525654, 0.00043384888, 0.0025286146, 0.00349777, 3.1624797f-5, 0.00017443944, -0.0033164807], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.98990935, 0.9927325, 0.99345046, 0.9694228, 1.0037662, 0.98568547, 0.99712723, 0.9872776, 1.0082906, 1.0044862 … 0.99839866, 1.0037067, 0.99369234, 0.99665964, 0.9925385, 0.958198, 0.97938985, 0.99434316, 1.0101033, 0.9903174], Float32[0.0046547917, -0.019893773, -0.009588573, 0.0028432165, 0.0047589364, -0.0028043785, 0.00833395, 0.009257588, 0.0071648816, 0.006460758 … -0.0042559416, -0.0088890875, -0.0017841165, -0.0037446455, -0.0112923, -0.05279327, 0.018110534, -0.0060070534, 0.005424199, -0.009653852], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " ),\n", @@ -580,12 +2858,12 @@ " NNlib.swish,\n", " ),\n", " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9999873, 1.0007596, 1.0004652, 0.9980036, 0.99611694, 0.99963504, 0.99828976, 0.9941192, 0.99682456, 1.0036113 … 0.9962207, 0.99932814, 1.0052634, 0.99965405, 0.99797845, 1.0021533, 0.99630314, 0.9962363, 0.9968872, 0.9950752], Float32[0.0016285058, 0.0010424233, 0.0014664369, -0.0014162131, 0.0017848933, 0.000904849, 0.00092839357, -0.0016400279, -0.001116365, -0.0033237175 … -0.00095372245, 0.001379597, -0.0012153891, 0.0021411562, -0.0018140029, 2.6796373f-5, 0.00015037494, -0.0011084817, -0.0011156661, 0.00032005878], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9813191, 0.97900933, 0.99497646, 0.9740931, 0.99270153, 0.9512806, 0.98416686, 0.98227394, 0.99777186, 0.9847334 … 0.97772944, 0.99356306, 0.99567527, 0.9884459, 0.99413466, 0.9872411, 0.9937668, 0.9934419, 0.9858429, 1.0006208], Float32[-0.008844349, -0.003362618, 0.007866318, 0.007047815, -0.0043394393, -0.011138873, 0.011454338, 0.0073125726, -0.0019595535, -0.005712127 … 0.0042020027, 0.012437841, 0.008444573, -0.010965995, 0.0033074883, 0.0013927073, -0.0025926381, 0.004861451, 0.0003271947, 0.0013459908], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " ),\n", " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[1.0022401, 0.9986023, 1.0036827, 1.0028428, 1.000628, 1.0002831, 1.0026282, 0.99865013, 1.0008336, 1.0011939 … 1.0003446, 0.99899316, 1.002376, 1.0019797, 0.99698734, 0.999672, 1.0006473, 1.0076064, 0.99772197, 0.9987918], Float32[0.00015093086, 0.0012914928, -0.003335636, 0.0020593128, 0.0022943593, -0.002442357, 0.002647567, -0.0009951793, 0.0038749017, 0.0015201706 … -0.00042401845, 0.0010297338, -0.0010947591, 0.0017330695, -0.0038933319, 0.0008850007, -0.0018997401, -0.0021773023, -0.0017003756, -0.0052421563], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.99184936, 1.0132029, 0.9949654, 0.99911726, 0.9930749, 1.004498, 1.0130638, 1.0191455, 1.0075065, 0.97904897 … 1.0130671, 1.0166669, 1.0298382, 1.0103947, 0.99601674, 0.97281563, 0.99154127, 1.0031415, 1.0141926, 0.9984006], Float32[0.0064145937, -0.012695074, -0.024113664, 0.0008978927, 0.008383268, -0.0046254005, 0.0058898213, -0.00048160343, 0.011751346, -0.001727852 … -0.011738534, -0.008813223, -0.0048925155, -0.002928767, -0.007028266, -0.028897885, 0.016255967, -0.008061163, -0.0006376766, -0.011933948], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " ),\n", @@ -612,32 +2890,173 @@ " NNlib.swish,\n", " ),\n", " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9968295, 0.99981964, 0.997613, 1.0026582, 1.0021008, 0.9980333, 0.9980151, 1.0059716, 0.9994964, 1.0015678 … 1.0007763, 1.0008732, 0.9982152, 0.996613, 1.009945, 1.0004773, 0.99887973, 0.99991816, 1.0020856, 1.0039768], Float32[-0.002375596, 0.0017580708, 0.0015227637, 0.002731847, -0.0018972742, 0.0016495208, 0.0021964826, 0.0021700887, -0.008651828, -0.0018713331 … -0.0012924711, -0.002237556, 0.0030750209, -0.0023795986, 0.0026068965, -0.0046221926, 0.0015926374, -0.0025060303, 0.002212718, -0.0010806752], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9871817, 0.97967505, 0.9925497, 0.9899778, 0.9875628, 1.0040362, 0.9646963, 0.98949474, 0.98805684, 0.9880806 … 1.0172434, 0.9862294, 1.0149201, 0.94580567, 1.0022846, 0.98350805, 0.99963933, 0.9940302, 1.0096109, 0.97280717], Float32[0.002797166, -0.00076662557, 0.00028469562, -0.0044771708, -0.0028138815, 0.003455172, 0.0049372525, 0.005800529, 0.0032799544, 0.0068818713 … 0.02613455, 0.006609633, 0.0013952806, 0.011928056, -0.008288531, -0.016250463, 0.006419934, -0.0055078357, -0.01332255, -0.016116258], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " ),\n", " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[1.0013795, 0.9984948, 0.9960571, 1.0029256, 1.0054785, 1.004133, 0.9986023, 1.0040288, 1.0013745, 1.0022346 … 0.99479765, 1.0003234, 1.0026337, 1.0049077, 0.99656516, 0.9970753, 1.0004745, 0.99843496, 0.9936143, 0.99871683], Float32[0.0003255698, 0.0014144776, -0.0015200237, -0.0031796026, -0.0032191605, -0.002849132, 0.0020276716, 0.0025240814, -0.0016611946, -0.0017054722 … -0.003542002, 0.0001635102, -0.0026410683, -0.0013011089, -0.001919553, -0.0027726274, 0.0012582649, -0.0031571249, 0.0023577497, 0.0023878366], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[1.0026083, 0.9906121, 1.0252106, 0.9807042, 1.0165613, 0.9926678, 1.0275302, 1.0164462, 1.0170248, 1.0145394 … 1.0104992, 1.0050902, 1.0078901, 1.0107113, 1.0065619, 0.99085945, 0.99034745, 1.0093502, 1.0229908, 0.9981014], Float32[0.00017921702, -0.014748752, 0.0016491384, 0.0112701375, 0.008428353, 0.0039549926, 0.016354358, -0.0023426865, 0.0004367487, 0.0045339833 … 0.0015938681, 0.0045206565, -0.00032513068, 0.0024292, 0.005038348, -0.020209014, -0.0013112819, 0.0021825603, -0.00091132557, 0.0007438597], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " ),\n", " identity,\n", " ),\n", " ],\n", - " Dense(128 => 41; bias=false), \u001b[90m# 5_248 parameters\u001b[39m\n", + " Dense(128 => 20; bias=false), \u001b[90m# 2_560 parameters\u001b[39m\n", + " Dense(128 => 20; bias=false), \u001b[90m# 2_560 parameters\u001b[39m\n", + " Dense(128 => 1; bias=false), \u001b[90m# 128 parameters\u001b[39m\n", + " Dense(128 => 1; bias=false), \u001b[90m# 128 parameters\u001b[39m\n", + " Dense(128 => 1; bias=false), \u001b[90m# 128 parameters\u001b[39m\n", " RoPE{Matrix{Float32}}(Float32[1.0 0.5403023 … -0.87528455 -0.065975994; 1.0 0.95041525 … 0.9552474 0.8159282; … ; 1.0 0.9999995 … -0.57972294 -0.5789079; 1.0 0.99999994 … 0.2726629 0.27235872], Float32[0.0 0.84147096 … -0.48360822 -0.9978212; 0.0 0.3109836 … 0.29580808 0.5781532; … ; 0.0 0.0009999999 … -0.8148137 -0.8153929; 0.0 0.0003162278 … 0.9621096 0.9621958]),\n", " 20,\n", - ") \u001b[90m # Total: 80 trainable arrays, \u001b[39m1_339_392 parameters,\n", - "\u001b[90m # plus 3 non-trainable, 65_600 parameters, summarysize \u001b[39m5.364 MiB." + ") \u001b[90m # Total: 84 trainable arrays, \u001b[39m1_339_648 parameters,\n", + "\u001b[90m # plus 3 non-trainable, 65_600 parameters, summarysize \u001b[39m5.365 MiB." + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model = train_editflow!(P, model; epochs=100, steps_per_epoch=150, batch_size=256, lr=1f-4)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "MersenneTwister(42)" ] }, - "execution_count": 17, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "model = train_editflow!(P, model; epochs=5, steps_per_epoch=150, batch_size=256, lr=1f-4)\n" + "rng=Random.MersenneTwister(42)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "10-element Vector{String}:\n", + " \"QVQLVQSGAEVKKPGA\"\n", + " \"QVLVQSGAGAVKKPRASVKV\"\n", + " \"QVQLVKSGEVLVKP\"\n", + " \"EVQLMESGGPYKP\"\n", + " \"QVQLVQSGAEVKKPGASVKV\"\n", + " \"QVQLVQSGTMVKKPGASS\"\n", + " \"QVQVVESGGGAVVQPGA\"\n", + " \"QVQLVQSGAEVEKPGA\"\n", + " \"QVQLVESGGGVVSQLGS\"\n", + " \"QVQWYQYGGPVKK\"" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model_samples_any = sample_gen_n(P, model; n=10, ts=0f0:0.01f0:1f0, rng)\n", + "model_final_states = map(final_state_from_gen, model_samples_any)\n", + "model_strings = [state_to_PM_string(P, s) for s in model_final_states]" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "10-element Vector{String}:\n", + " \"EVQLVESGGGLVKPPGQLR\"\n", + " \"QVQLVQSKAEVKKPGASVKV\"\n", + " \"EGQRVECGGGGGQRG\"\n", + " \"EVQLVESGGGLV\"\n", + " \"QVQLVQSGAAV\"\n", + " \"EVQLVESGGGLVQPGGSLTL\"\n", + " \"QVQLVESGGGVVQPCR\"\n", + " \"QVLLVQSGTEVFKPGASMKV\"\n", + " \"QVLLVQSTAEVKK\"\n", + " \"QITLKESDPTLVKP\"" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_states = [FF.DiscreteState(P.k, sample(PM; rng=rng)) for i in 1:10]\n", + "train_strings = [state_to_PM_string(P, s) for s in train_states]" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1000-element Vector{String}:\n", + " \"QVQLVESGGRV\"\n", + " \"QLQLGQSGAVV\"\n", + " \"QVQLVESGGGVVQPGR\"\n", + " \"QITLKESYPTLVKPS\"\n", + " \"EVQLVLESGGLVQPGASLRL\"\n", + " \"EEQLVESGGGVVQPG\"\n", + " \"QVQLVQSGAEVK\"\n", + " \"QVQLVQSGGEPGCVGTLRL\"\n", + " \"QQLTQKYGTAVKEGASVHV\"\n", + " \"QVQLVLSSAEVKKP\"\n", + " \"QLQLQESGPGLVKP\"\n", + " \"EVQLVESGGYLVQPGG\"\n", + " \"QLQLQESGPGVVQPGRSL\"\n", + " ⋮\n", + " \"QVQLVQSGAEVK\"\n", + " \"QVQLVESGGGVKPGR\"\n", + " \"EVHLVESGGGLVKPGGS\"\n", + " \"Q\"\n", + " \"QVQLVQYGANVVKPGASVKV\"\n", + " \"QVLLVQSGAEVKKYGTSVHV\"\n", + " \"QVQLVESSQGHVMQQPGR\"\n", + " \"QVQRAQAGAESKKPGTSVKV\"\n", + " \"QIQIKETGPGLFK\"\n", + " \"QVQLQKSGPGLVK\"\n", + " \"QVVQLQQPGAYVK\"\n", + " \"MVLVQSGAEV\"" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Sampling and Levenshtein plot\n", + "using Random\n", + "n = 1000\n", + "# 100 model samples (final states → strings)\n", + "model_samples_any = sample_gen_n(P, model; n=n, ts=0f0:0.01f0:1f0, rng=rng)\n", + "model_final_states = map(final_state_from_gen, model_samples_any)\n", + "model_strings = [state_to_PM_string(P, s) for s in model_final_states]\n", + "\n", + "\n" ] }, { @@ -645,207 +3064,214 @@ "execution_count": null, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32mProgress: 100%|█████████████████████████████████████████| Time: 0:00:00\u001b[39m\n" + ] + }, { "data": { - "image/png": "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", + "image/png": "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", "image/svg+xml": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ], "text/html": [ - "" + "" ] }, "metadata": {}, @@ -853,26 +3279,20 @@ } ], "source": [ - "# Sampling and Levenshtein plot\n", - "using Random\n", - "n = 1000\n", - "# 100 model samples (final states → strings)\n", - "model_samples_any = sample_gen_n(P, model; n=n, ts=0f0:0.01f0:1f0, rng=Random.MersenneTwister(42))\n", - "model_final_states = map(final_state_from_gen, model_samples_any)\n", - "model_strings = [state_to_PM_string(P, s) for s in model_final_states]\n", - "\n", + "m = 100\n", + "p=100000\n", "# Build training strings from PM parents (the data PM was built on)\n", - "train_states = [FF.DiscreteState(P.k, sample(PM; rng=Random.MersenneTwister(1000+i))) for i in 1:100]\n", + "train_states = [FF.DiscreteState(P.k, sample(PM; rng=rng)) for i in 1:m]\n", "train_strings = [state_to_PM_string(P, s) for s in train_states]\n", "\n", "# Independent validation strings sampled from PM\n", - "val_states = [FF.DiscreteState(P.k, sample(PM; rng=Random.MersenneTwister(1000+i+2*n))) for i in 1:n]\n", + "val_states = [FF.DiscreteState(P.k, sample(PM; rng=rng)) for i in 1:p]\n", "val_strings = [state_to_PM_string(P, s) for s in val_states]\n", "#val_strings = [s for s in val_strings if !(s in train_strings)]\n", "\n", "# Plot normalized Levenshtein vs. training set (distinct val/train)\n", "plt = plot_lev_dist(\"model_vs_true\", val_strings, model_strings, train_strings; title=\"Model vs True (normalized Levenshtein)\")\n", - "display(plt)\n" + "display(plt)" ] }, { @@ -1095,192 +3515,230 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "image/svg+xml": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ], "text/html": [ - "" + "" ] }, "metadata": {}, @@ -1288,187 +3746,187 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "image/svg+xml": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ], "text/html": [ - "" + "" ] }, "metadata": {}, @@ -1477,11 +3935,18 @@ ], "source": [ "\n", - "pAA = plot_AA_dist(\"model_vs_true_AA\", val_strings, model_strings; title=\"AA frequency: Natural vs Generated\")\n", - "display(pAA)\n", + "n=1000000\n", + "val_states = [FF.DiscreteState(P.k, sample(PM; rng)) for i in 1:n]\n", + "val_strings = [state_to_PM_string(P, s) for s in val_states]\n", + "\n", + "\n", "\n", "pLen = plot_len_dist(\"model_vs_true_len\", val_strings, model_strings; title=\"Length distribution: Natural vs Generated\")\n", - "display(pLen)\n" + "display(pLen)\n", + "\n", + "pAA = plot_AA_dist(\"model_vs_true_AA\", val_strings, model_strings; title=\"AA frequency: Natural vs Generated\")\n", + "display(pAA)\n", + "\n" ] }, { @@ -1522,8 +3987,241 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "data": { + "text/plain": [ + "MersenneTwister(42)" + ] + }, + "execution_count": 183, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rng = Random.MersenneTwister(42)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "" + ] + }, + "execution_count": 226, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "n=1000000\n", + "val_states = [FF.DiscreteState(P.k, sample(PM; rng)) for i in 1:n]\n", + "val_strings = [state_to_PM_string(P, s) for s in val_states]\n", + "pLen = plot_len_dist(\"model_vs_true_len\", val_strings, val_strings; title=\"Length distribution: Natural vs Generated\")\n" + ] } ], "metadata": { diff --git a/editflow_code/analysis_notebook.ipynb b/editflow_code/analysis_notebook.ipynb index 662e339..5f89613 100644 --- a/editflow_code/analysis_notebook.ipynb +++ b/editflow_code/analysis_notebook.ipynb @@ -279,20 +279,20 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "# Init process and model\n", "K = PM.K\n", - "P = FF.EditFlow(K; bos_token=0, gap_wise=false)\n", + "P = FF.EditFlow(K; bos_token=0, impl=\"positionwise\")\n", "model = EditFlowModel(; d=128, num_heads=8, nlayers=4, rff_dim=128, cond_dim=128, K=K)\n", "nothing" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -302,2403 +302,2403 @@ "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.746237f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 83.736786f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.981628f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 64.495285f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.213884f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 58.378933f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.454155f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 57.44657f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.665428f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 53.10153f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.873983f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 52.092472f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.157003f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 51.066406f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 15.275973f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 50.10228f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.903381f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 52.646454f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.729305f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 48.27961f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.102013f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 47.068417f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.672424f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 47.148155f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.530746f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 47.38747f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.67213f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 48.832336f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.382526f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 46.620193f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.963814f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 42.772224f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.835972f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 42.5094f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.291992f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 42.68994f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.19426f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 45.21868f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.382185f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 44.735287f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.135967f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 46.219032f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.92569f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 43.771515f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.028893f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 43.439323f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.427214f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 42.391823f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 17.69117f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 42.078323f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.73476f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 40.584442f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.384754f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 39.591778f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.658775f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 39.200012f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.132454f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 40.52163f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.998142f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 39.95525f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.203682f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 40.43916f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.36901f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 36.585854f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.243134f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 35.356228f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.106112f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 38.881367f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.82871f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 38.805748f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.493202f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 35.150246f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.290234f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 36.453175f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.923895f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 34.729294f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.832842f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 36.946503f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.057846f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 37.86364f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.94542f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.87124f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.881554f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 35.39663f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.718155f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 36.202248f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.733717f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 34.723198f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.073797f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.529686f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.92004f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 35.60004f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.047007f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 34.809135f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.872967f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 37.7173f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.382488f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 38.98217f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.645565f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 34.840153f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.287525f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 34.501328f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.113968f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.74812f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.087315f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 35.057404f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.874767f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 34.000618f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.860031f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.70163f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.602049f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.00467f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.410063f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.5678f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 10.562942f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.228672f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.848387f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.80764f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.861128f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 35.22995f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 11\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.541365f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 35.077126f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 11\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.236982f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.4538f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 11\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.957115f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.589409f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 11\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.865005f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 35.388657f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 11\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.583748f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.60462f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 11\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.02132f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.976006f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 12\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.584347f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 35.120266f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 12\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.580858f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.904274f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 12\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.981087f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.141886f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 12\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.591656f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.246605f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 12\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.066517f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 35.357933f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 12\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.051542f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.575096f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 13\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.067421f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 34.58333f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 13\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.05304f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.69362f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 13\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.487747f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.440308f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 13\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.222967f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.269135f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 13\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.143532f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.07043f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 13\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.575806f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.747131f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 14\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.158926f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 34.33024f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 14\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.09401f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.970945f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 14\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.851517f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.395454f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 14\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.892365f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 34.25579f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 14\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.7897f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.79269f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 14\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.985878f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.479609f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 15\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.019676f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.445f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 15\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.797548f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.247536f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 15\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.55872f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.59025f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 15\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.278553f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.697208f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 15\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.254448f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.190733f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 15\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.536222f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.571495f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 16\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.821463f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.303825f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 16\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 17.80231f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.956326f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 16\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.376482f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.458134f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 16\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.044758f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.182348f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 16\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.442654f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.247002f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 16\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.176807f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.867138f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 17\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.091465f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.944284f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 17\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.013334f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.953032f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 17\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.81593f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.891912f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 17\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.212975f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.455013f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 17\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.84259f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.257238f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 17\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.185429f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.763453f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 18\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.470398f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.838593f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 18\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.427452f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 38.515694f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 18\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.94579f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.590763f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 18\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.695702f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.413822f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 18\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.645878f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.312204f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 18\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.073719f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.033407f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 19\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.841595f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.60764f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 19\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.278421f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.683825f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 19\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.68238f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.99452f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 19\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.269619f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.840446f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 19\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.283346f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.511087f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 19\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.181093f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.609032f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 20\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.541328f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.4864f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 20\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.628794f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.20541f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 20\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.634392f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.57394f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 20\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.7462f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.533508f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 20\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.353523f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.234636f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 20\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.927622f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.236277f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 21\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.720219f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.206926f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 21\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.47013f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 39.105427f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 21\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.810509f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.148418f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 21\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.401003f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.41487f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 21\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.512375f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.457407f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 21\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.377796f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.143053f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 22\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.350807f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.106377f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 22\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 16.468513f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.804495f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 22\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.804567f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.133682f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 22\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.310434f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.526081f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 22\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.925941f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.901348f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 22\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.39031f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.19005f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 23\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.91434f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.04325f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 23\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.262634f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.695435f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 23\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.324049f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.443134f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 23\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.413176f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.771538f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 23\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.26462f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 34.52459f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 23\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.746334f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.840496f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 24\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.85251f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.486713f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 24\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.560282f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.46355f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 24\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.03707f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.09877f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 24\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.268227f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.597292f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 24\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.471123f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.051674f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 24\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.593208f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.237413f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 25\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.767986f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.406393f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 25\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.076988f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.998531f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 25\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.13642f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.69793f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 25\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.121529f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.059692f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 25\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.215782f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.66899f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 25\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.73236f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.294348f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 26\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.485447f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.32547f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 26\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.659838f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.664577f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 26\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.290493f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.806381f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 26\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 16.489616f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.793175f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 26\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.764778f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.744194f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 26\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.014236f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.675987f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 27\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.763737f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.006525f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 27\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.692177f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.526497f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 27\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.253918f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.859245f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 27\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.51273f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.286953f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 27\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.86855f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.619637f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 27\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.306889f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.287895f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 28\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.108227f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.271503f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 28\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.949062f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.422726f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 28\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.045507f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.784676f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 28\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.165205f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.556908f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 28\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 12.919155f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.694458f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 28\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.903103f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.163525f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 29\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.889954f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.873146f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 29\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.677599f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.183922f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 29\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.235676f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.459885f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 29\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.818413f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.21161f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 29\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.454956f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.297506f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 29\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.443413f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.238375f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 30\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.767849f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.762661f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 30\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.12367f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.615551f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 30\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.95783f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.84065f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 30\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.690418f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.567947f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 30\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.498676f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.795734f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 30\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.116188f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.091413f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 31\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.376179f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.664131f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 31\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.445965f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.703232f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 31\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.826906f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.87818f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 31\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.523788f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.085363f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 31\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 16.482994f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.510078f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 31\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.550964f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.59261f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 32\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.193125f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.155712f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 32\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.838432f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.622356f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 32\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.289452f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.947422f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 32\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.098053f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.411736f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 32\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.513762f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.89394f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 32\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.862543f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.753727f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 33\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 16.810226f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.005175f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 33\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.037594f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.618238f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 33\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.468763f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.975243f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 33\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.604746f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.257711f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 33\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.249472f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.162008f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 33\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.916328f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.73898f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 34\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.879818f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.676374f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 34\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.453798f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.940678f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 34\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.617702f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.975033f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 34\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.713636f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.908325f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 34\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.131275f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.258303f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 34\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.763681f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.460526f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 35\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.138496f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.309393f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 35\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.24766f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.002573f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 35\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.000917f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.906958f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 35\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.266335f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.911507f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 35\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.831928f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.348392f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 35\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.104105f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.920475f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 36\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.901894f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.161407f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 36\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.866064f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.016054f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 36\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.89682f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.069206f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 36\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.663845f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.558964f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 36\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.070297f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.510098f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 36\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.728453f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.373135f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 37\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.615274f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.989553f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 37\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.564804f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.674725f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 37\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.089449f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.202068f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 37\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.273602f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.977032f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 37\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.159435f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.359718f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 37\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.562922f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.482635f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 38\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.734241f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.643867f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 38\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.008451f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.819004f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 38\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 8.860302f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.471022f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 38\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.15115f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.273146f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 38\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.32642f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.748596f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 38\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.513498f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.305868f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 39\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.381474f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.273132f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 39\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.2743f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.225166f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 39\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.010727f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.65695f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 39\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.264381f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.454845f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 39\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.826624f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.29239f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 39\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.921288f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.975653f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 40\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.755466f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.466633f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 40\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.364662f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.652067f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 40\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.126223f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.060982f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 40\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.64931f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.826948f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 40\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.564432f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.575483f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 40\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.728107f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.241547f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 41\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 17.909348f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.450838f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 41\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.832344f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.159214f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 41\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.323364f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.561043f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 41\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.952206f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.646994f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 41\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.968285f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.33515f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 41\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.83363f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.36123f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 42\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.986597f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.514114f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 42\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.239515f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.115816f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 42\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.450031f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.29996f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 42\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.893978f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.94608f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 42\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.543922f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.038818f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 42\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.674696f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.111692f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 43\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.830986f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.719038f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 43\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.515713f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.08482f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 43\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.128778f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.023565f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 43\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.751575f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.564959f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 43\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.633709f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.322641f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 43\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.873392f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.822062f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 44\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.810955f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.313103f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 44\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.402004f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.501802f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 44\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.716564f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.16099f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 44\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 17.452545f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.877111f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 44\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 16.890793f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.238403f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 44\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.448315f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.569504f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 45\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.888472f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.029053f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 45\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.899237f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.206123f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 45\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.195805f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.914211f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 45\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.420376f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.062172f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 45\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.594948f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.873936f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 45\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 9.004853f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 17.07422f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 46\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.887007f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.084599f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 46\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.23485f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.350561f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 46\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.913727f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.928856f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 46\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.218992f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.360596f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 46\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.94302f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.616196f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 46\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.745415f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.380928f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 47\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.451485f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.335377f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 47\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.83382f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.877655f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 47\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.155079f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.43614f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 47\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.894794f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.86212f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 47\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.932127f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.343979f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 47\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.041811f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.994446f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 48\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.656693f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.88852f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 48\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.531162f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.639826f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 48\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.119312f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.220734f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 48\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.319973f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.02056f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 48\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.268059f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.744844f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 48\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.691246f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.17317f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 49\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.474157f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.761208f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 49\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.733646f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.338768f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 49\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.136124f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.998962f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 49\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 17.320087f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.325726f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 49\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.540567f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.02639f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 49\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.147991f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.685146f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 50\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.83776f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.348274f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 50\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.327303f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.31087f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 50\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.39455f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.900738f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 50\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.208961f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.373507f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 50\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.616371f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.563559f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 50\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.594536f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.769222f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 51\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.58604f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.408052f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 51\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.868906f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.554232f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 51\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.821358f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.177116f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 51\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.95021f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.358053f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 51\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.622738f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.82463f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 51\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.146685f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.957832f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 52\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.15935f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.096786f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 52\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.340935f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.303093f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 52\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.693542f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.216187f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 52\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.80805f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.714031f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 52\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.283953f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.774612f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 52\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.714622f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.130646f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 53\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.754047f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.937706f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 53\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.48253f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.784252f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 53\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.189365f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.24423f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 53\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.135786f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.30219f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 53\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.220694f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.690536f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 53\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.33191f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.283348f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 54\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.619081f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.20753f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 54\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.133217f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.712158f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 54\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.216085f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.816628f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 54\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.81441f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.449432f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 54\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.997604f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.840046f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 54\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.05939f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.925455f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 55\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 16.644253f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.76426f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 55\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.239815f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.861675f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 55\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.43597f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.432695f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 55\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 16.8848f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.923695f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 55\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.401718f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.43818f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 55\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.64897f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.35653f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 56\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.992f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.026611f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 56\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.69675f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.830933f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 56\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.861366f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.0928f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 56\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.179195f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.389936f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 56\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = -11.587956f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 8.432835f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 56\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.98692f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.253635f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 57\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.81665f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.281342f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 57\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.926167f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.784367f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 57\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.971962f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.119469f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 57\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.27145f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.110329f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 57\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.326494f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.42931f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 57\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.14252f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.3354f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 58\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.31263f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.20557f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 58\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.074333f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.855927f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 58\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.830984f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.680237f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 58\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.307228f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.67761f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 58\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.105434f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.310575f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 58\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.807196f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.247278f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 59\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.067299f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.36555f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 59\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.049335f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.678894f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 59\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.681822f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.489243f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 59\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.253326f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.97666f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 59\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 17.409986f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.396267f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 59\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.683414f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.857048f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 60\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.863966f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.645363f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 60\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 15.980584f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.345028f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 60\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.086948f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.0388f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 60\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.897078f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.372253f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 60\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.529032f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.957508f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 60\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.82579f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.146568f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 61\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.25418f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.9666f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 61\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.34762f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.987667f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 61\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.448723f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.835585f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 61\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.228636f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.015417f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 61\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.144558f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.046053f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 61\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.490255f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.865223f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 62\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.441963f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.974688f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 62\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.559408f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.343489f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 62\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.865923f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.349274f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 62\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.954279f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.972279f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 62\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.403667f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.305977f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 62\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.830547f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.5912f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 63\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.544434f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.355446f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 63\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.088642f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.177032f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 63\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 5.486371f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 10.863924f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 63\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.702126f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.891338f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 63\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.829082f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.208794f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 63\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.889729f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.2947f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 64\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.04778f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.390572f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 64\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.33698f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.165335f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 64\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.940506f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.150234f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 64\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.096375f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.791471f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 64\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.802752f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.49009f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 64\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.215298f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.730213f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 65\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.598557f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.899033f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 65\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.455418f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.423372f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 65\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.71409f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.001375f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 65\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.750744f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.270048f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 65\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.510859f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.136654f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 65\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.624943f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.949314f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 66\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.001049f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.983856f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 66\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.153976f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.217213f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 66\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.199299f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.731222f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 66\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.778515f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.801033f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 66\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.019203f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.530155f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 66\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.27776f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.205227f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 67\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.881886f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.18843f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 67\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.737415f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.44056f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 67\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.321026f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.498363f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 67\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.270313f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.111303f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 67\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.653442f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.864407f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 67\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.653757f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.832945f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 68\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.06898f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.754612f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 68\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.069595f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.552414f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 68\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.993654f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.798717f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 68\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.809895f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.308937f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 68\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.706173f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.032734f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 68\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.573029f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.386208f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 69\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.283886f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.889053f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 69\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.783833f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.17315f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 69\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.422552f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.749578f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 69\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.811619f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.154047f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 69\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.002556f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.899586f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 69\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.116966f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.518412f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 70\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.023243f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.620747f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 70\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.249037f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.48816f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 70\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.984207f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.395489f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 70\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.499313f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.867355f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 70\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.772282f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.831955f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 70\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.921055f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.63542f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 71\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.7816f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.006498f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 71\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.670277f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.910547f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 71\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.296196f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.852781f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 71\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.030935f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.053795f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 71\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.194506f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.566113f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 71\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.43831f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.93971f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 72\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.557142f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.719915f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 72\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.490828f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.567732f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 72\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.104092f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.067009f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 72\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.674341f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.630566f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 72\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.07388f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.881369f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 72\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.306126f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.283709f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 73\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.135044f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.977842f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 73\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.159412f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.78251f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 73\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.045418f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.719252f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 73\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.40194f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.831766f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 73\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.572552f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.329166f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 73\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.981903f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.031353f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 74\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.257917f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.762793f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 74\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.122993f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.656246f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 74\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.006748f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.323887f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 74\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.172253f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.773823f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 74\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.008356f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.346474f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 74\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.84019f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.026167f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 75\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.151068f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.21579f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 75\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.485172f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.9039f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 75\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.153769f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.340492f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 75\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.290163f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.337955f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 75\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.762228f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.05367f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 75\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.199116f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.19878f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 76\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 17.930504f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.578243f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 76\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.04787f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.400549f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 76\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.809868f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.024925f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 76\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.353975f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.77185f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 76\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.562157f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.733723f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 76\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 16.483915f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.22491f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 77\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.138283f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.374962f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 77\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.523014f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.460857f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 77\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.520844f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.585602f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 77\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.04196f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.67676f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 77\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.441517f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.2365f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 77\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.367897f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.163668f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 78\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.163624f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.8737f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 78\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.393862f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.085178f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 78\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.718964f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.73316f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 78\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.644243f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.050098f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 78\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.149078f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.015127f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 78\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.814312f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.484646f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 79\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.866508f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.067255f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 79\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.337425f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.27439f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 79\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.624027f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.9315f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 79\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.402237f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.541557f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 79\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.410057f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.650444f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 79\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.08833f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.9324f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 80\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.47953f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.217312f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 80\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.978199f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.473713f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 80\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.085361f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.991798f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 80\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.211655f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.86194f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 80\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.508362f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.710724f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 80\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.466614f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.826077f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 81\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.391834f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.596859f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 81\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.903198f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.356354f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 81\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.485249f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.686537f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 81\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.64059f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.67141f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 81\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.317387f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.553585f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 81\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.682806f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.449818f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 82\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.254333f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.063112f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 82\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.734877f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.716024f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 82\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.537487f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.03563f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 82\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.094929f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.361609f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 82\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.800623f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.226782f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 82\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.080275f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.583712f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 83\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.002201f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.711393f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 83\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.30722f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.704826f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 83\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.413658f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.818869f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 83\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.382023f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.524006f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 83\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.645979f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.562775f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 83\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.672878f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.114517f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 84\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.800962f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.352974f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 84\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.22847f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.355661f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 84\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.500309f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.83047f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 84\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.74908f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.845814f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 84\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.878939f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.498404f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 84\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.335938f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.70013f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 85\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.956377f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.050747f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 85\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.555515f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.63451f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 85\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.946405f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.280785f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 85\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.589813f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.248508f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 85\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.090248f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.548471f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 85\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.336586f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.571407f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 86\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.855642f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.952906f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 86\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.779556f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.956108f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 86\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.152008f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.773396f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 86\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.799198f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.57819f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 86\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.729807f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.362558f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 86\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.73042f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.141186f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 87\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.806095f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.48025f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 87\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.405361f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.950367f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 87\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.57449f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.04166f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 87\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.7407f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.06808f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 87\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.59734f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.057018f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 87\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.25967f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.645393f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 88\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.743744f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.471352f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 88\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.98431f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.250923f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 88\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 15.31344f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.898548f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 88\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.085484f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.286873f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 88\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.487297f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.45379f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 88\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.491331f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.93012f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 89\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 16.660719f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.791477f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 89\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.529898f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.859566f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 89\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.550985f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.819387f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 89\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.375748f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.355679f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 89\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.937206f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.759441f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 89\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.631706f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.459671f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 90\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 17.535595f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.304174f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 90\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.669437f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.914288f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 90\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.55685f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.268284f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 90\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.808851f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.05593f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 90\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.87554f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.075645f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 90\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.389326f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.650444f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 91\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.405817f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.8277f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 91\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.464638f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.521507f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 91\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.111252f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.136765f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 91\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.999516f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.51986f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 91\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.218391f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.753933f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 91\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.187355f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.429028f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 92\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.420967f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.900995f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 92\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.060745f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.481503f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 92\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.60073f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.095737f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 92\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.225628f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.633944f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 92\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.36546f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.3988f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 92\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.678913f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.896637f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 93\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.350622f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.8027f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 93\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.95152f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.98824f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 93\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.601427f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.93037f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 93\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.351856f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.596542f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 93\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.845188f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.370098f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 93\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.619637f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.074085f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 94\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.598852f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.232698f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 94\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.265049f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.135914f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 94\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.088186f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.110563f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 94\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.131905f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.074043f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 94\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.927309f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.367891f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 94\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.709093f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.681921f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 95\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.480736f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.592049f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 95\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.990673f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.301102f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 95\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.88835f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.338062f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 95\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.45876f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.938211f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 95\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.846493f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.074715f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 95\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.63565f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.870651f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 96\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.12495f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.193409f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 96\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.763638f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.031347f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 96\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.331306f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.18711f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 96\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.594742f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.878101f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 96\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.491268f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.586113f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 96\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.579607f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.230448f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 97\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.1447f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.917355f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 97\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.514366f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.331898f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 97\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.976524f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.469292f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 97\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.168167f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.97321f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 97\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.450222f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.545681f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 97\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.13343f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.428368f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 98\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.17472f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.110815f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 98\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.017311f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.728079f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 98\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.751623f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.234997f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 98\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.171782f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.222769f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 98\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.81949f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.157688f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 98\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.225515f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.667023f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 99\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.012215f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.824947f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 99\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.367924f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.08692f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 99\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.439997f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.797817f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 99\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.901167f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.392517f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 99\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.113953f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.88201f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 99\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.226475f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.279892f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 100\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.480293f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.646812f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 100\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.56205f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.505789f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 100\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.577469f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.102386f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 100\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.884739f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.912247f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 100\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.706923f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.428463f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 100\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.257725f0\n" + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.633018f0\n" ] }, { @@ -2707,7 +2707,7 @@ "EditFlowModel(\n", " Embedding(22 => 128), \u001b[90m# 2_816 parameters\u001b[39m\n", " Chain(\n", - " RandomFourierFeatures{Float32, Matrix{Float32}}(Float32[4.107619 -1.6246507 … -3.6645346 -1.3967112]),\n", + " RandomFourierFeatures{Float32, Matrix{Float32}}(Float32[1.7281183 -8.28652 … 0.6994802 8.02288]),\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " ),\n", " [\n", @@ -2732,12 +2732,12 @@ " NNlib.swish,\n", " ),\n", " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.96080273, 0.93640083, 0.9547064, 0.8971493, 0.95765316, 0.92207366, 0.89724094, 0.9440924, 0.94302225, 0.94956416 … 0.94014513, 0.9212964, 0.91572565, 0.9039559, 0.9231686, 0.9042348, 0.9314332, 0.87426275, 0.8752597, 0.9407146], Float32[-0.025268404, 0.0020312557, -0.010115526, 0.020099802, 0.018506693, 0.0025694135, -0.023937318, -0.038941544, -0.038218282, -0.008356358 … 0.0045030406, 0.029052407, -0.039042093, -0.009993242, 0.003901428, -0.0070870365, -0.037610408, -0.06006574, 0.015338725, 0.011129025], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.95842546, 0.98741066, 0.98946583, 0.96391237, 0.99079794, 0.98914933, 0.9886823, 0.9912729, 0.9776449, 0.97661537 … 1.0056453, 0.9699813, 0.98405874, 0.98403525, 0.9776771, 0.9858879, 0.9667122, 0.96873516, 0.9970507, 0.9510425], Float32[-0.018506369, -0.004576628, -0.0052596675, -0.0013863416, -0.0020905286, -0.0082345465, -0.009565522, 0.0036397565, 0.0073073274, 0.00245158 … -0.004794393, -0.003127396, 0.004971791, 0.008037141, 0.006695991, 0.004149384, -0.007730862, 0.009864908, 0.0014894081, -0.008365696], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " ),\n", " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9615473, 0.97570944, 0.9112915, 0.96853894, 0.9237012, 0.9523371, 0.9733101, 0.9436969, 1.0086424, 0.98759335 … 0.96384525, 0.98503447, 0.9836052, 0.95819885, 0.969784, 0.9607591, 0.9873663, 1.0246212, 0.97779596, 0.963771], Float32[-0.027013712, -0.0054144724, 0.0071041402, -0.015267112, -0.05662798, -0.00019226706, 0.017086789, 0.010009103, 0.004368342, -0.022684177 … 0.008213096, 0.01543913, 0.008588103, -0.042858012, 0.005013047, -0.0087100575, -0.00035417278, -0.0044492367, -3.3963931f-6, -0.0070771035], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[1.0012316, 0.97387743, 0.9838116, 0.9914654, 0.99690056, 0.99384093, 0.9899602, 1.0077832, 0.9974476, 1.0028224 … 1.0038843, 1.000784, 0.9901355, 0.97226375, 0.99053144, 0.99020875, 0.98688054, 0.979344, 0.9902409, 0.9838954], Float32[0.002815563, -0.0024851928, -0.0083595365, -5.25621f-6, -0.0067214165, -0.002657918, -0.0013004369, 0.0034968748, 0.01953269, -0.0008888415 … -0.0023656685, -0.0054193716, -0.0116233425, 0.015501341, -0.003890949, -0.0019308609, 0.00049372844, 0.00034903453, -0.0028637475, -0.017084926], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " ),\n", @@ -2764,12 +2764,12 @@ " NNlib.swish,\n", " ),\n", " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.94601697, 0.97375804, 0.9406857, 0.953404, 0.95697165, 0.9183645, 0.93461883, 0.93530893, 0.98690313, 0.92145735 … 0.8612234, 0.87250346, 0.98907375, 0.956685, 0.9498322, 0.9437079, 0.9624967, 0.949929, 0.97197264, 0.97001827], Float32[0.0011167054, -0.014636964, 0.0022019444, 0.0121619, -0.013723163, 0.001547043, 0.011414896, -0.0012122085, -0.006493586, -0.021626603 … 0.069353715, -0.012018405, 0.004048702, 0.004974579, -0.017438088, -0.010104225, -0.009309289, 4.483607f-5, -0.012501754, -0.006304365], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.98124874, 0.99294347, 0.97263086, 0.97624344, 0.9692242, 0.99422336, 1.0007071, 0.9877409, 0.9835757, 0.96854764 … 0.9916055, 0.9497232, 0.9818755, 0.98545647, 0.986695, 0.9832109, 0.9825076, 0.9861389, 0.9652221, 0.9917089], Float32[0.008366182, 0.0025968729, -0.0046521705, 0.0059934966, 0.0037380015, -0.006058944, -0.00213039, -0.0015994225, -0.0002880596, -0.008941856 … -0.0011073721, -0.0033712026, 0.0024713897, 0.00090915087, 0.0027050162, -0.00049480854, -0.0021957606, -0.00026154608, -0.0007733444, 0.0035458663], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " ),\n", " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.97332007, 1.0309724, 0.9687911, 0.97576725, 0.96835095, 0.9971229, 0.993208, 0.9710502, 1.003863, 0.9820828 … 0.982708, 0.92708766, 1.0036467, 0.9794132, 0.99849373, 0.9908135, 0.9964946, 1.0093178, 0.9900424, 0.9617081], Float32[-0.016477505, -0.014338043, 0.040039297, -0.029744757, -0.029461078, -0.041657545, 0.027084501, 0.041064046, -0.025039643, 0.0060120723 … 0.0095715625, -0.0138390735, 0.0026735286, -0.050670695, -0.024575308, 0.006731998, -0.007667666, -6.0379556f-5, -0.0033010722, -0.048479233], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.98954874, 1.0064409, 1.0006205, 0.9687034, 1.0105321, 0.9992001, 1.001568, 0.9937505, 1.0011319, 0.9962604 … 1.0047686, 1.0296574, 1.003038, 0.999967, 0.9874898, 1.0177082, 0.99866545, 1.0067143, 1.0165161, 0.97980374], Float32[0.010105973, 0.0027944609, -0.013623008, 0.00015286788, 0.010491903, -0.014361129, 0.0029192131, 0.010968703, 0.02183013, -0.0075194403 … 0.0031368278, -0.0069664246, 0.005510949, 0.0029950426, -0.016416242, 0.004190883, -0.009001297, 0.0016531029, 0.00023697296, -0.016956057], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " ),\n", @@ -2796,12 +2796,12 @@ " NNlib.swish,\n", " ),\n", " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.94413495, 0.9591206, 0.9815761, 0.9860674, 0.9643858, 0.99948543, 0.95805496, 0.9728332, 0.9892072, 0.93138975 … 0.92429256, 1.0070444, 0.9443377, 0.9681403, 0.9447193, 0.9323913, 0.9746358, 0.99652237, 0.96340334, 0.97654444], Float32[-0.03537166, -0.006217378, -0.007379122, 0.009719772, -0.0314247, 0.016313963, -0.0015389565, 0.021076221, 0.010470716, -0.02639406 … 0.0006755494, 0.005295955, 0.017049158, -0.0132954335, 0.005307746, 0.02653267, -0.008163272, 0.009826559, 0.030178566, -0.0014013725], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9971892, 1.0052998, 0.9738435, 1.0002576, 0.9848593, 0.9861847, 0.99767387, 0.9885801, 0.99154145, 0.994766 … 0.9916212, 0.9969682, 0.9904124, 0.99198806, 0.9954721, 0.9834797, 0.99912214, 0.9854371, 0.9942954, 0.9913383], Float32[0.0015207408, -0.0033681458, -0.0023985226, -0.00065797754, -0.009101785, -0.004139576, 0.00064375135, -0.0009410129, -0.007824935, 0.00028769727 … 0.0037259334, 0.0076854243, -0.005058262, 0.0020828305, -0.008041701, -0.011211128, 0.0007848889, -0.0037174162, 0.00958359, -0.012076021], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " ),\n", " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.93666166, 1.0321827, 0.9726321, 0.98780626, 0.9613221, 1.0248475, 1.0161513, 0.96915793, 0.9948018, 1.0429728 … 1.0270013, 1.0185184, 1.0062677, 0.9811149, 1.0302101, 1.0181782, 1.0179951, 1.0333631, 1.0274625, 0.9702701], Float32[-0.06427912, 0.002420664, 0.047289338, -0.034010448, -0.03299984, -0.013876393, 0.023457177, 0.020834371, 0.010680823, -0.032694057 … -0.003318202, -0.0250829, 0.027400794, -0.031808987, -0.024685763, -0.00258377, -0.011304101, -0.01021114, -0.0004895934, -0.020227717], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9926784, 1.0099522, 1.018655, 1.0246687, 1.0155983, 0.999562, 1.0058562, 1.0086799, 1.0027, 1.0159949 … 1.0171447, 1.0185226, 1.0222071, 1.0119679, 0.9941316, 0.9831888, 1.0129008, 1.0232303, 0.9945741, 1.010639], Float32[0.021637583, 0.0026361896, 0.0030154746, 0.0054475893, 0.0016284249, -0.0013797352, -0.005838183, 0.020362949, 0.0166286, 0.0027873395 … -6.395481f-5, -0.009351911, -0.0040145507, 0.0037398424, -0.0024497798, 0.0036764992, -0.0019770127, -0.007801793, -0.0034624704, -0.018143063], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " ),\n", @@ -2828,12 +2828,12 @@ " NNlib.swish,\n", " ),\n", " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.98147184, 0.9223102, 1.0042982, 0.97599345, 0.98011535, 0.9964276, 0.9762427, 0.94932944, 0.96026486, 0.95611215 … 0.9575027, 0.9455124, 0.99811995, 0.9754665, 0.9862882, 0.9942666, 0.9694813, 0.96348906, 0.95470506, 0.9039463], Float32[-0.014831864, 9.283005f-5, -0.008477221, 0.040162712, 0.022272639, 0.0436828, -0.009014154, 0.055058725, 0.030263849, -0.040652655 … -0.010325852, -0.023909276, 0.009594226, 0.00861934, -0.0045753345, -0.015833346, 0.019944627, 0.011142825, 0.025711212, 0.026980491], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[1.0005784, 1.0023686, 0.9926611, 0.9971379, 0.9893593, 0.99703175, 0.98693585, 0.98417956, 0.99158716, 0.9840834 … 0.9798584, 1.0009283, 0.992765, 1.0134311, 0.97082436, 0.9919511, 0.99050313, 1.0135138, 1.0075364, 1.0050263], Float32[0.0028692435, 0.001397007, -0.00031375163, 0.00011770211, -0.00019967364, 0.0031852166, 0.016907748, -0.00036422213, -0.006018046, 0.0019798558 … 0.0064551155, 0.005405687, -0.0051399246, 0.010505294, -0.008053577, 0.0004768742, -0.005301881, 0.0049994923, -0.0021463423, 0.00065149594], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " ),\n", " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9566518, 1.0749155, 1.0178746, 1.0410086, 1.0265093, 1.0722593, 1.0385908, 1.0496945, 1.1038729, 1.003326 … 1.0357652, 1.005023, 1.0573806, 1.0052382, 0.98908836, 1.0178303, 1.110416, 1.0397507, 1.0142217, 1.0475482], Float32[-0.08760491, 0.051100586, 0.08073487, -0.080240734, -0.037350997, -0.064348176, 0.01896439, 0.012915793, 0.041853514, -0.02849257 … -0.012428334, -0.040537376, 0.026203565, -0.026402708, -0.039873, -0.0071864277, 0.023559058, -0.015315336, 0.05209827, -0.06641875], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9948915, 1.0199512, 1.0060881, 1.0226755, 1.0125494, 1.0088879, 1.032922, 1.0230399, 0.9945264, 1.0315107 … 1.0220547, 1.0145272, 0.9960454, 1.0164645, 0.99917156, 1.0051632, 1.005905, 1.0241879, 0.99837464, 1.0323802], Float32[0.014390601, -0.0032132757, 0.009422892, -0.010013719, 0.0012736539, -0.009157955, 0.012012328, 0.00047939247, 0.021873204, 0.0057482067 … 0.0038961642, -0.0050933673, 0.0025382934, -0.016774157, -0.009548492, -0.004478543, -0.006396792, -0.003149633, -0.002905998, 0.0020193828], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " ),\n", @@ -2847,225 +2847,51 @@ "\u001b[90m # plus 3 non-trainable, 65_600 parameters, summarysize \u001b[39m5.364 MiB." ] }, - "execution_count": 13, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "model = train_editflow!(P, model; epochs=100, steps_per_epoch=150, batch_size=256, lr=1f-4)\n" + "model = train_editflow!(P, model; epochs=50, steps_per_epoch=150, batch_size=256, lr=1f-4)\n" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 15, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", - "image/svg+xml": [ - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" - ], - "text/html": [ - "" + "text/plain": [ + "MersenneTwister(123023)" ] }, + "execution_count": 15, "metadata": {}, - "output_type": "display_data" + "output_type": "execute_result" + } + ], + "source": [ + "rng = Random.MersenneTwister(123023)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "ename": "LoadError", + "evalue": "ParseError:\n\u001b[90m# Error @ \u001b[0;0m\u001b]8;;file:///home/theodor/dev/Flowfusion.jl/editflow_code/In[16]#10:59\u001b\\\u001b[90mIn[16]:10:59\u001b[0;0m\u001b]8;;\u001b\\\n# Build training strings from PM parents (the data PM was built on)\ntrain_states = [FF.DiscreteState(P.k, sample(PM; rng=rng))\u001b[48;2;120;70;70m\u001b[0;0m) for i in 1:100]\n\u001b[90m# └ ── \u001b[0;0m\u001b[91mExpected `]`\u001b[0;0m", + "output_type": "error", + "traceback": [ + "ParseError:\n\u001b[90m# Error @ \u001b[0;0m\u001b]8;;file:///home/theodor/dev/Flowfusion.jl/editflow_code/In[16]#10:59\u001b\\\u001b[90mIn[16]:10:59\u001b[0;0m\u001b]8;;\u001b\\\n# Build training strings from PM parents (the data PM was built on)\ntrain_states = [FF.DiscreteState(P.k, sample(PM; rng=rng))\u001b[48;2;120;70;70m\u001b[0;0m) for i in 1:100]\n\u001b[90m# └ ── \u001b[0;0m\u001b[91mExpected `]`\u001b[0;0m", + "", + "Stacktrace:", + " [1] top-level scope", + "\u001b[90m @\u001b[39m \u001b[90m\u001b[4mIn[16]:10\u001b[24m\u001b[39m" + ] } ], "source": [ @@ -3073,230 +2899,239 @@ "using Random\n", "n = 1000\n", "# 100 model samples (final states → strings)\n", - "model_samples_any = sample_gen_n(P, model; n=n, ts=0f0:0.01f0:1f0, rng=Random.MersenneTwister(42))\n", + "model_samples_any = sample_gen_n(P, model; n=n, ts=0f0:0.01f0:1f0, rng=rng)\n", "model_final_states = map(final_state_from_gen, model_samples_any)\n", "model_strings = [state_to_PM_string(P, s) for s in model_final_states]\n", "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ "# Build training strings from PM parents (the data PM was built on)\n", - "train_states = [FF.DiscreteState(P.k, sample(PM; rng=Random.MersenneTwister(1000+i))) for i in 1:100]\n", + "train_states = [FF.DiscreteState(P.k, sample(PM; rng=rng)) for i in 1:100]\n", "train_strings = [state_to_PM_string(P, s) for s in train_states]\n", "\n", "# Independent validation strings sampled from PM\n", - "val_states = [FF.DiscreteState(P.k, sample(PM; rng=Random.MersenneTwister(1000+i+2*n))) for i in 1:n]\n", + "val_states = [FF.DiscreteState(P.k, sample(PM; rng=rng)) for i in 1:n]\n", "val_strings = [state_to_PM_string(P, s) for s in val_states]\n", "#val_strings = [s for s in val_strings if !(s in train_strings)]\n", "\n", "# Plot normalized Levenshtein vs. training set (distinct val/train)\n", "plt = plot_lev_dist(\"model_vs_true\", val_strings, model_strings, train_strings; title=\"Model vs True (normalized Levenshtein)\")\n", - "display(plt)\n" + "display(plt)" ] }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 11, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "image/svg+xml": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ], "text/html": [ - "" + "" ] }, "metadata": {}, @@ -3311,192 +3146,192 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "image/svg+xml": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ], "text/html": [ - "" + "" ] }, "metadata": {}, @@ -3504,187 +3339,205 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "image/svg+xml": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ], "text/html": [ - "" + "" ] }, "metadata": {}, @@ -3702,14 +3555,14 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Natural 'A' frequency: 0.047142480905978404\n" + "Natural 'A' frequency: 0.04562383612662942\n" ] } ], @@ -3719,20 +3572,27 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Natural 'A' frequency: 0.04109772423025435\n" + "Natural 'A' frequency: 0.051578034296390206\n" ] } ], "source": [ "println(\"Natural 'A' frequency: \", (isdefined(Main, :model_strings) ? sum(count(==('A'), s) for s in model_strings) / sum(length.(model_strings)) : sum(count(==('A'), s) for s in model_strings) / sum(length.(model_strings))))" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/editflow_code/gapwise_editflowsrun.jl b/editflow_code/gapwise_editflowsrun.jl index f910cb4..385dbaf 100644 --- a/editflow_code/gapwise_editflowsrun.jl +++ b/editflow_code/gapwise_editflowsrun.jl @@ -197,7 +197,7 @@ end K = PM.K println("K: ", K) -P = FF.EditFlow(K; bos_token=0) +P = FF.EditFlow(K; bos_token=0, impl="positionwise_reparam") model = EditFlowModel(; d=128, num_heads=8, nlayers=4, rff_dim=128, cond_dim=128, K=K) diff --git a/src/editflows.jl b/src/editflows.jl index aa551b5..9f1b395 100644 --- a/src/editflows.jl +++ b/src/editflows.jl @@ -20,7 +20,7 @@ _coerce_impl(x::AbstractString) = begin end end -_resolve_impl(impl) = impl === nothing ? GAPWISE : _coerce_impl(impl) +_resolve_impl(impl) = impl === nothing ? POSITIONWISE_REPARAM : _coerce_impl(impl) struct EditFlow <: DiscreteProcess k::Int # alphabet size (tokens 1..k) @@ -41,7 +41,7 @@ const EDITFLOW_DISPATCH_STRINGS = ( EditFlow(k; transform = NNlib.softplus, κ = identity, - dκ = t -> one(eltype(t)), + dκ = t -> one(t), padding_token::Int = k + 1, latent_token::Int = k + 2, bos_token::Int = 0, @@ -195,8 +195,12 @@ end function transition_mask_from_Xt(P::EditFlow, Xt::AbstractMatrix{<:Integer}) if P.impl == GAPWISE return transition_mask_from_Xt_gapwise(P, Xt) - else + elseif P.impl == POSITIONWISE return transition_mask_from_Xt_positionwise(P, Xt) + elseif P.impl == POSITIONWISE_REPARAM + return transition_mask_from_Xt_positionwise_reparam(P, Xt) + else + error("Unknown EditFlow implementation: $(P.impl)") end end @@ -266,9 +270,11 @@ function transition_mask_from_Xt_gapwise(P::EditFlow, Xt::AbstractMatrix{<:Integ end return M end + function transition_mask_from_Xt_positionwise_reparam(P::EditFlow, Xt::AbstractMatrix{<:Integer}) tokens = P.k pad = P.padding_token + bos = P.bos_token xt_len, B = size(Xt) ins_q_mask = ones(Float32, tokens, xt_len, B) sub_q_mask = ones(Float32, tokens, xt_len, B) @@ -277,7 +283,7 @@ function transition_mask_from_Xt_positionwise_reparam(P::EditFlow, Xt::AbstractM del_lambda_mask = ones(Float32, 1, xt_len, B) for b in 1:B x = Xt[:,b] - Lb = count(t -> t != PAD, x) + Lb = count(t -> t != pad, x) # Mask the padding ins_q_mask[:, (Lb+1):xt_len, b] .= 0 sub_q_mask[:, (Lb+1):xt_len, b] .= 0 @@ -285,28 +291,40 @@ function transition_mask_from_Xt_positionwise_reparam(P::EditFlow, Xt::AbstractM sub_lambda_mask[:, (Lb+1):xt_len, b] .= 0 del_lambda_mask[:, (Lb+1):xt_len, b] .= 0 #Mask the BOS for sub and del - sub_q_mask[:, 1, b] .= 0 - sub_lambda_mask[:, 1, b] .= 0 - del_lambda_mask[:, 1, b] .= 0 + # forbid sub/del at BOS iff BOS present at i=1 + if Lb >= 1 && x[1] == bos + sub_q_mask[:, 1, b] .= 0 + sub_lambda_mask[:, 1, b] .= 0 + del_lambda_mask[:, 1, b] .= 0 + end + # sub_q_mask[:, 1, b] .= 0 + # sub_lambda_mask[:, 1, b] .= 0 + # del_lambda_mask[:, 1, b] .= 0 #Mask the self-substitutions for i in 2:Lb t = x[i] if 1 <= t <= tokens - sub_q_mask[t, i, b] .= 0 + sub_q_mask[t, i, b] = 0 else throw(ArgumentError("Invalid token: $t")) end end - return (ins_q_mask, sub_q_mask, ins_lambda_mask, sub_lambda_mask, del_lambda_mask) + end + return (ins_q_mask, sub_q_mask, ins_lambda_mask, sub_lambda_mask, del_lambda_mask) end function remaining_edits(P::EditFlow, Zt::Matrix{Int}, Z1::Matrix{Int}, Xt::Matrix{Int}, dense=false) if P.impl == GAPWISE return remaining_edits_gapwise(P, Zt, Z1, Xt) - else + elseif P.impl == POSITIONWISE return remaining_edits_positionwise(P, Zt, Z1, Xt) + elseif P.impl == POSITIONWISE_REPARAM + return remaining_edits_positionwise_reparam(P, Zt, Z1, Xt) + else + error("Unknown EditFlow implementation: $(P.impl)") end end + # Compute the remaining edits for the EditFlow as a Matrix function remaining_edits_positionwise(P::EditFlow, Zt::Matrix{Int}, Z1::Matrix{Int}, Xt::Matrix{Int}, dense=false) padding_token = P.padding_token @@ -337,6 +355,7 @@ function remaining_edits_positionwise(P::EditFlow, Zt::Matrix{Int}, Z1::Matrix{I b = Z1 .!= latent_token c = Z1 .!= Zt subs = Z1.*(a .& b .& c) + sub_edits = zeros(Float32, (tokens, batch_length, batch_size)) sub_indices = findall(!iszero, subs) sub_cols_to_update = pos[sub_indices] @@ -348,7 +367,7 @@ function remaining_edits_positionwise(P::EditFlow, Zt::Matrix{Int}, Z1::Matrix{I dense_subs = (sub_rows_to_update .+ tokens, sub_cols_to_update, sub_samples_to_update) #Del - dels = Z1 .== latent_token + dels = (Z1 .== latent_token) .& (Zt .!= latent_token) del_edits = zeros(Float32, (1, batch_length, batch_size)) del_indices = findall(!iszero, dels) del_cols_to_update = pos[del_indices] @@ -452,7 +471,11 @@ function remaining_edits_positionwise_reparam(P::EditFlow, Zt::AbstractMatrix{<: dense_subs = (sub_rows_to_update .+ tokens, sub_cols_to_update, sub_samples_to_update) #Del - dels = Z1 .== latent_token + #tmp = Z1 .== latent_token + dels = (Z1 .== latent_token) .& (Zt .!= latent_token) + + #@assert tmp == dels "Assertion failed: tmp != dels" + del_edits = zeros(Float32, (1, batch_length, batch_size)) del_indices = findall(!iszero, dels) del_cols_to_update = pos[del_indices] @@ -476,8 +499,12 @@ function step(P::EditFlow, s1::Real, s2::Real) if P.impl == GAPWISE return step_gapwise(P, hat, Xt, s1, s2) - else + elseif P.impl == POSITIONWISE return step_positionwise(P, Xt, hat, s1, s2) + elseif P.impl == POSITIONWISE_REPARAM + return step_positionwise_reparam(P, hat, Xt, s1, s2) + else + error("Unknown EditFlow implementation: $(P.impl)") end end @@ -710,6 +737,241 @@ function rollout_gapwise(P::EditFlow, model, x0::DiscreteState, ts::AbstractVect return x end +# --- helper: robust slice for (K,L,1)/(K,L) -> (K,L) and (1,L,1)/(1,L)/L -> Vector --- +@inline _KL(A) = ndims(A) == 3 ? Array(@view A[:, :, 1]) : + ndims(A) == 2 ? Array(A) : + error("Expected (K,L,1) or (K,L), got size $(size(A))") + +@inline _L(A) = ndims(A) == 3 ? vec(Array(@view A[1, :, 1])) : + ndims(A) == 2 ? vec(Array(@view A[1, :])) : + ndims(A) == 1 ? vec(Array(A)) : + error("Expected (1,L,1) or (1,L) or (L,), got size $(size(A))") + +""" +One CTMC Euler step for POSITIONWISE_REPARAM. + +`hat` is a tuple (ins_q_logits, sub_q_logits, ins_lambda, sub_lambda, del_lambda) +for the current sequence, with shapes (K,L,1)/(K,L) for logits and (1,L,1)/(1,L)/L for lambdas. +Insertions are defined per *site* here: gap g=2..L+1 uses site g-1; gap 1 (pre-BOS) is blocked. +""" +function step_positionwise_reparam( + P::EditFlow, + hat, # (ins_q_logits, sub_q_logits, ins_λ, sub_λ, del_λ) + Xt::DiscreteState{<:AbstractVector{<:Signed}}, + t1::Real, t2::Real; + rng::AbstractRNG = Random.default_rng(), +) + @assert t2 > t1 + dt = Float64(t2 - t1) + + # unpack + shapes -> arrays on CPU (OK for sampling) + ins_q_logits, sub_q_logits, ins_λ_raw, sub_λ_raw, del_λ_raw = hat + ins_q = NNlib.softmax(_KL(ins_q_logits); dims=1) # (K,L) + sub_q = NNlib.softmax(_KL(sub_q_logits); dims=1) # (K,L) + ins_λ = P.transform(_L(ins_λ_raw)) # (L,) + sub_λ = P.transform(_L(sub_λ_raw)) # (L,) + del_λ = P.transform(_L(del_λ_raw)) # (L,) + + x = collect(tensor(Xt)) # Vector{Int} + K = P.k + L = length(x) + + # guard: empty sequence quick path + if L == 0 + # Only allow a single "after last" insertion; reuse last-site rule -> none here; return as-is + return Xt + end + + # --- forbid BOS edits and pre-BOS insert policy --- + if x[1] == P.bos_token + sub_q[:, 1] .= 0 + sub_λ[1] = 0 + del_λ[1] = 0 + end + + # --- forbid self-substitutions (zero prob, no renorm needed) --- + @inbounds for i in 1:L + tok = x[i] + if 1 <= tok <= K + sub_q[tok, i] = 0 + else + # Non-vocab token at site i → block substitutions at this site + sub_q[:, i] .= 0 + sub_λ[i] = 0 + end + end + + # -------- site events (delete or substitute) -------- + to_delete = falses(L) + sub_to = zeros(Int, L) + @inbounds for i in 1:L + r_del = max(del_λ[i], 0.0) + r_sub_total = max(sub_λ[i], 0.0) * sum(@view sub_q[:, i]) + r_tot = r_del + r_sub_total + if r_tot > 0 && rand(rng) < (1 - exp(-dt * r_tot)) + u = rand(rng) * r_tot + if u < r_del + to_delete[i] = true + elseif r_sub_total > 0 + # sample token ∝ sub_q[:, i] + cs = cumsum(@view sub_q[:, i]) + sub_to[i] = _pick_index1d!(rng, cs) + end + end + end + + # -------- gap insertions (≤1 per gap) -------- + # gap g in 1..L+1; g==1 (pre-BOS) is blocked; use site (g-1) rates otherwise, + # and for g==L+1 reuse site L. + ins_tok = fill(0, L + 1) + @inbounds for g in 2:(L+1) + src = min(g - 1, L) # site index providing insertion rates for this gap + r_vec = (@view ins_q[:, src]) .* ins_λ[src] + r_tot = sum(r_vec) + if r_tot > 0 && rand(rng) < (1 - exp(-dt * r_tot)) + cs = cumsum(r_vec) + ins_tok[g] = _pick_index1d!(rng, cs) + end + end + # explicitly block pre-BOS insert + ins_tok[1] = 0 + + # -------- build new sequence -------- + result = Int[] + if ins_tok[1] != 0; push!(result, ins_tok[1]); end + @inbounds for i in 1:L + if !to_delete[i] + a = (sub_to[i] == 0) ? x[i] : sub_to[i] + push!(result, a) + end + if ins_tok[i + 1] != 0 + push!(result, ins_tok[i + 1]) + end + end + + return DiscreteState(Xt.K, result) +end + + +#= +@inline _KL(A) = ndims(A) == 3 ? Array(@view A[:, :, 1]) : + ndims(A) == 2 ? Array(A) : + error("Expected (K,L,1) or (K,L), got size $(size(A))") + +@inline _L(A) = ndims(A) == 3 ? vec(Array(@view A[1, :, 1])) : + ndims(A) == 2 ? vec(Array(@view A[1, :])) : + ndims(A) == 1 ? vec(Array(A)) : + error("Expected (1,L,1) or (1,L) or (L,), got size $(size(A))") + +function step_positionwise_reparam( + P::EditFlow, + hat, # (ins_q_logits, sub_q_logits, ins_λ, sub_λ, del_λ) + Xt::DiscreteState{<:AbstractVector{<:Signed}}, + t1::Real, t2::Real; + rng::AbstractRNG = Random.default_rng(), +) + @assert t2 > t1 + dt = Float64(t2 - t1) + + # unpack → arrays + ins_q_logits, sub_q_logits, ins_λ_raw, sub_λ_raw, del_λ_raw = hat + ins_q = NNlib.softmax(_KL(ins_q_logits); dims=1) # (K,L) + sub_q = NNlib.softmax(_KL(sub_q_logits); dims=1) # (K,L) + ins_λ = P.transform(_L(ins_λ_raw)) # (L,) + sub_λ = P.transform(_L(sub_λ_raw)) # (L,) + del_λ = P.transform(_L(del_λ_raw)) # (L,) + + x = collect(tensor(Xt)) + K = P.k + L = length(x) + if L == 0 + return Xt + end + + # --- κ-scaling to encourage growth over time --- + κt = clamp(float(P.κ(t2)), 0.0, 1.0) + ins_λ .*= κt + del_λ .*= (1 - κt) + # (sub_λ unchanged; keep neutral) + + # --- BOS policy + small insert floor at first site (gap 2) --- + if x[1] == P.bos_token + sub_q[:, 1] .= 0 + sub_λ[1] = 0 + del_λ[1] = 0 + λmin = eltype(ins_λ)(1e-3) + ins_λ[1] = max(ins_λ[1], λmin) + end + + # --- forbid self-substitutions / non-vocab guards --- + @inbounds for i in 1:L + tok = x[i] + if 1 <= tok <= K + sub_q[tok, i] = 0 + else + sub_q[:, i] .= 0 + sub_λ[i] = 0 + end + end + + # -------- site events (delete or substitute) -------- + to_delete = falses(L) + sub_to = zeros(Int, L) + @inbounds for i in 1:L + r_del = max(del_λ[i], 0.0) + r_sub_total = max(sub_λ[i], 0.0) * sum(@view sub_q[:, i]) + r_tot = r_del + r_sub_total + if r_tot > 0 && rand(rng) < (1 - exp(-dt * r_tot)) + u = rand(rng) * r_tot + if u < r_del + to_delete[i] = true + elseif r_sub_total > 0 + cs = cumsum(@view sub_q[:, i]) + sub_to[i] = _pick_index1d!(rng, cs) + end + end + end + + # -------- gap insertions (≤1 per gap) -------- + # gap g=1..L+1 ; g==1 (pre-BOS) blocked; use site (g-1), with L reused for g==L+1 + ins_tok = fill(0, L + 1) + @inbounds for g in 2:(L+1) + src = min(g - 1, L) + r_vec = (@view ins_q[:, src]) .* ins_λ[src] + r_tot = sum(r_vec) + if r_tot > 0 && rand(rng) < (1 - exp(-dt * r_tot)) + cs = cumsum(r_vec) + ins_tok[g] = _pick_index1d!(rng, cs) + end + end + ins_tok[1] = 0 # block pre-BOS insert + + # -------- build new sequence -------- + result = Int[] + if ins_tok[1] != 0; push!(result, ins_tok[1]); end + @inbounds for i in 1:L + if !to_delete[i] + a = (sub_to[i] == 0) ? x[i] : sub_to[i] + push!(result, a) + end + if ins_tok[i + 1] != 0 + push!(result, ins_tok[i + 1]) + end + end + + # -------- BOS-only guard (rare fallback) -------- + if length(result) == 1 && result[1] == P.bos_token + r_vec = (@view ins_q[:, 1]) .* ins_λ[1] # use first site’s insertion rates + if sum(r_vec) > 0 + cs = cumsum(r_vec) + push!(result, _pick_index1d!(rng, cs)) + end + end + + return DiscreteState(Xt.K, result) +end + +=# #= @@ -736,7 +998,7 @@ function edit_loss(P::EditFlow, M, transition_mask, edit_multiplier, scheduler_s elseif P.impl == POSITIONWISE return edit_loss_positionwise(P, M, transition_mask, edit_multiplier, scheduler_scaling; op_mask=op_mask, eps=eps) elseif P.impl == POSITIONWISE_REPARAM - return edit_loss_positionwise_reparam(P, M, transition_mask, edit_multiplier, scheduler_scaling; op_mask=op_mask, eps=eps) + return edit_loss_positionwise_reparam(P, M, transition_mask, edit_multiplier, scheduler_scaling; eps=eps) end end @@ -803,26 +1065,91 @@ function edit_loss_gapwise(P::EditFlow, return mean(loss_per_batch) end + +#= function edit_loss_positionwise_reparam(P::EditFlow, M, transition_mask, edit_multiplier, scheduler_scaling; eps=1e-8) (ins_q_mask, sub_q_mask, ins_lambda_mask, sub_lambda_mask, del_lambda_mask) = transition_mask (ins_q, sub_q, ins_lambda, sub_lambda, del_lambda) = M - ins_q = softmax(ins_q, dims=1) - sub_q = softmax(sub_q, dims=1) - ins_lambda = P.transform(ins_q) - sub_lambda = P.transform(sub_q) - del_lambda = P.transform(del_lambda) - loss_term_1 = sum(ins_lambda.* ins_lambda_mask + sub_lambda.* sub_lambda_mask + del_lambda.* del_lambda_mask) + # pre-softmax mask (safe -Inf with Float32 works; on some accelerators prefer -1e9f0) + #ins_q = NNlib.softmax(ins_q_logits .+ ifelse.(ins_q_mask .> 0, 0f0, negInf), dims=1) + #sub_q = NNlib.softmax(sub_q_logits .+ ifelse.(sub_q_mask .> 0, 0f0, negInf), dims=1) + # ins_q = NNlib.softmax(ins_q, dims=1) + # sub_q = NNlib.softmax(sub_q, dims=1) + + # probs + ins_q = NNlib.softmax(ins_q; dims=1); ins_q .*= ins_q_mask + sub_q = NNlib.softmax(sub_q; dims=1); sub_q .*= sub_q_mask + + ins_lambda = P.transform(ins_lambda); ndims(ins_lambda)==2 && (ins_lambda = reshape(ins_lambda, 1, size(ins_lambda,1), size(ins_lambda,2))) + sub_lambda = P.transform(sub_lambda); ndims(sub_lambda)==2 && (sub_lambda = reshape(sub_lambda, 1, size(sub_lambda,1), size(sub_lambda,2))) + del_lambda = P.transform(del_lambda); ndims(del_lambda)==2 && (del_lambda = reshape(del_lambda, 1, size(del_lambda,1), size(del_lambda,2))) + + # regularizer (sum of *allowed* mass) + sum_ins_q = sum(ins_q; dims=1) + sum_sub_q = sum(sub_q; dims=1) + loss_term_1 = sum(ins_lambda .* ins_lambda_mask .* sum_ins_q .+ + sub_lambda .* sub_lambda_mask .* sum_sub_q .+ + del_lambda .* del_lambda_mask; dims=(1,2)) + + + #loss_term_1 = sum(ins_lambda.* ins_lambda_mask + sub_lambda.* sub_lambda_mask + del_lambda.* del_lambda_mask, dims=(1,2)) scl = reshape(scheduler_scaling, 1, 1, :) # (1,1,B) - - #hmm fix shape of lambdas they might be vectors... - ins_rate_log = log.(max.(ins_lambda.* ins_q, eltype(ins_lambda)(eps))) - sub_rate_log = log.(max.(sub_lambda .* sub_q, eltype(R)(eps))) - del_rate_log = log.(max.(del_lambda, eltype(R)(eps))) + # ins_lambda = reshape(ins_lambda, 1, size(ins_lambda)...) + # sub_lambda = reshape(sub_lambda, 1, size(sub_lambda)...) + # del_lambda = reshape(del_lambda, 1, size(del_lambda)...) + + ins_rate_log = log.(max.(ins_lambda .* ins_q, eltype(ins_lambda)(eps))) + sub_rate_log = log.(max.(sub_lambda .* sub_q, eltype(sub_lambda)(eps))) + del_rate_log = log.(max.(del_lambda, eltype(del_lambda)(eps))) + + (ins_q_edits, sub_q_edits, del_lambda_edits) = edit_multiplier + loss_term_2 = sum(scl .* (ins_q_edits .* ins_rate_log), dims=(1,2)) + + sum(scl .* (sub_q_edits .* sub_rate_log), dims=(1,2)) + + sum(scl .* (del_lambda_edits .* del_rate_log), dims=(1,2)) + return mean(loss_term_1 .- loss_term_2) +end +=# + +function edit_loss_positionwise_reparam(P::EditFlow, + M, transition_mask, edit_multiplier, scheduler_scaling; eps=1e-8) + + (ins_q_mask, sub_q_mask, ins_lambda_mask, sub_lambda_mask, del_lambda_mask) = transition_mask + (ins_q_logits, sub_q_logits, ins_lambda, sub_lambda, del_lambda) = M + + # q: post-softmax + mask (K,L,B) + ins_q = NNlib.softmax(ins_q_logits; dims=1) .* ins_q_mask + sub_q = NNlib.softmax(sub_q_logits; dims=1) .* sub_q_mask + + # λ: transform -> (1,L,B) + ins_lambda = P.transform(ins_lambda); ndims(ins_lambda)==2 && (ins_lambda = reshape(ins_lambda, 1, size(ins_lambda,1), size(ins_lambda,2))) + sub_lambda = P.transform(sub_lambda); ndims(sub_lambda)==2 && (sub_lambda = reshape(sub_lambda, 1, size(sub_lambda,1), size(sub_lambda,2))) + del_lambda = P.transform(del_lambda); ndims(del_lambda)==2 && (del_lambda = reshape(del_lambda, 1, size(del_lambda,1), size(del_lambda,2))) + + # term 1: sum of allowed exit rates (1,B) + sum_ins_q = sum(ins_q; dims=1) # (1,L,B) + sum_sub_q = sum(sub_q; dims=1) # (1,L,B) + loss_term_1 = sum(ins_lambda .* ins_lambda_mask .* sum_ins_q .+ + sub_lambda .* sub_lambda_mask .* sum_sub_q .+ + del_lambda .* del_lambda_mask; dims=(1,2)) + + + + # term 2: data term (1,B) + scl = reshape(scheduler_scaling, 1, 1, :) (ins_q_edits, sub_q_edits, del_lambda_edits) = edit_multiplier - loss_term_2 = sum( (ins_q_edits .* ins_q_log) + () ) + ins_rate_log = log.(max.(ins_lambda .* ins_q, eltype(ins_lambda)(eps))) + sub_rate_log = log.(max.(sub_lambda .* sub_q, eltype(sub_lambda)(eps))) + del_rate_log = log.(max.(del_lambda, eltype(del_lambda)(eps))) + + loss_term_2 = sum(scl .* (ins_q_edits .* ins_rate_log); dims=(1,2)) + + sum(scl .* (sub_q_edits .* sub_rate_log); dims=(1,2)) + + sum(scl .* (del_lambda_edits .* del_rate_log); dims=(1,2)) + + return mean(loss_term_1 .- loss_term_2) end + """ getlmask(P::EditFlow, Xt::AbstractMatrix{<:Integer}) @@ -832,4 +1159,3 @@ function getlmask(P::EditFlow, Xt::AbstractMatrix{<:Integer}) padding_token = P.padding_token return Xt .!= padding_token end - From a675472a6e310993b736ff9e755760bf5ac7d11e Mon Sep 17 00:00:00 2001 From: Glowster Date: Fri, 14 Nov 2025 14:08:35 +0100 Subject: [PATCH 9/9] recommiting the same things --- editflow_code/analysis_notebook.ipynb | 3166 +++++++++---------------- 1 file changed, 1104 insertions(+), 2062 deletions(-) diff --git a/editflow_code/analysis_notebook.ipynb b/editflow_code/analysis_notebook.ipynb index 5f89613..c32ea1c 100644 --- a/editflow_code/analysis_notebook.ipynb +++ b/editflow_code/analysis_notebook.ipynb @@ -10,6 +10,9 @@ "output_type": "stream", "text": [ "\u001b[32m\u001b[1m Activating\u001b[22m\u001b[39m project at `~/dev/Flowfusion.jl/editflow_code`\n", + "\u001b[92m\u001b[1mPrecompiling\u001b[22m\u001b[39m project...\n", + " 2266.3 ms\u001b[32m ✓ \u001b[39mFlowfusion\n", + " 1 dependency successfully precompiled in 4 seconds. 470 already precompiled.\n", "\u001b[32m\u001b[1m Resolving\u001b[22m\u001b[39m package versions...\n", "\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `~/dev/Flowfusion.jl/editflow_code/Project.toml`\n", "\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `~/dev/Flowfusion.jl/editflow_code/Manifest.toml`\n", @@ -279,7 +282,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -292,7 +295,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -302,2403 +305,1203 @@ "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 83.736786f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 77.32212f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 64.495285f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 62.010212f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 58.378933f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 54.765823f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 57.44657f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 55.06506f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 53.10153f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 51.20858f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 1\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 52.092472f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 49.92301f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 51.066406f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 49.66504f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 50.10228f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 48.609978f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 52.646454f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 51.766243f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 48.27961f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 46.577633f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 47.068417f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 46.013363f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 2\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 47.148155f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 44.984547f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 47.38747f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 45.69627f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 48.832336f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 48.54598f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 46.620193f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 46.083076f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 42.772224f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 41.404823f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 42.5094f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 41.41694f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 3\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 42.68994f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 40.346214f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 45.21868f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 44.24388f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 44.735287f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 42.988144f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 46.219032f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 44.356007f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 43.771515f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 43.046814f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 43.439323f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 44.238304f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 4\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 42.391823f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 42.40614f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 42.078323f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 40.038864f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 40.584442f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 39.248238f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 39.591778f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 39.251083f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 39.200012f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 38.37234f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 40.52163f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 39.504143f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 5\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 39.95525f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 38.68367f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 40.43916f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 39.95724f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 36.585854f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 36.87685f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 35.356228f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 34.32936f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 38.881367f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 37.77718f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 38.805748f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 37.4764f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 6\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 35.150246f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 34.697372f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 36.453175f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 35.233315f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 34.729294f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 34.579445f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 36.946503f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 37.07529f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 37.86364f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 37.277664f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.87124f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.53584f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 7\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 35.39663f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 35.566807f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 36.202248f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 36.145203f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 34.723198f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 36.07258f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.529686f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.562103f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 35.60004f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 35.07919f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 34.809135f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 34.078888f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 8\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 37.7173f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 37.076546f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 38.98217f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 36.745842f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 34.840153f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 35.205795f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 34.501328f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.40426f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.74812f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.041412f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 35.057404f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 34.140083f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 9\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 34.000618f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.82329f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.70163f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.56766f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.00467f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.306625f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.5678f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.299297f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.228672f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.544945f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.80764f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.594986f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 10\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 35.22995f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 35.99458f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 11\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 35.077126f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 35.273575f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 11\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.4538f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.578995f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 11\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.589409f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.579735f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 11\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 35.388657f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 34.745888f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 11\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.60462f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.89444f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 11\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.976006f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 34.12862f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 12\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 35.120266f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 34.716965f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 12\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.904274f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.7956f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 12\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.141886f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.485348f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 12\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.246605f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.210342f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 12\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 35.357933f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 34.249763f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 12\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.575096f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.991463f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 13\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 34.58333f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.865524f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 13\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.69362f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.39278f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 13\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.440308f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.85763f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 13\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.269135f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.728132f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 13\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.07043f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.789724f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 13\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.747131f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.589245f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 14\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 34.33024f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.698822f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 14\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.970945f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.386007f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 14\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.395454f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.859806f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 14\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 34.25579f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.39788f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 14\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.79269f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.370934f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 14\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.479609f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.334873f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 15\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.445f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.145905f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 15\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.247536f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.896702f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 15\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.59025f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.935232f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 15\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.697208f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.63628f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 15\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.190733f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.987965f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 15\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.571495f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.22433f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 16\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.303825f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.780943f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 16\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.956326f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.084726f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 16\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.458134f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.95314f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 16\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.182348f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.072214f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 16\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.247002f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.637058f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 16\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.867138f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.1978f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 17\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.944284f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.311502f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 17\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.953032f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.983727f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 17\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.891912f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.378075f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 17\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.455013f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.824142f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 17\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.257238f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.99437f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 17\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.763453f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.723846f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 18\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.838593f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.51981f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 18\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 38.515694f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 34.55582f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 18\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.590763f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.413897f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 18\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.413822f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.88297f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 18\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.312204f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.492455f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 18\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.033407f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.25613f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 19\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.60764f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.992672f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 19\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.683825f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.894299f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 19\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.99452f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.46797f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 19\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.840446f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.885025f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 19\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.511087f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.204609f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 19\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.609032f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.554102f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 20\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.4864f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.592083f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 20\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.20541f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.41414f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 20\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.57394f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.871262f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 20\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.533508f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.159111f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 20\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.234636f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.342709f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 20\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.236277f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.10995f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 21\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.206926f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.296486f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 21\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 39.105427f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.800013f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 21\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.148418f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.61753f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 21\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 33.41487f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.39122f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 21\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.457407f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.753365f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 21\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.143053f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.641577f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 22\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.106377f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.24447f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 22\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.804495f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.80323f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 22\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.133682f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.964045f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 22\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.526081f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.822504f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 22\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.901348f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.006264f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 22\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.19005f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.91555f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 23\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.04325f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.783787f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 23\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.695435f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.890472f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 23\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.443134f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.845434f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 23\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.771538f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.83451f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 23\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 34.52459f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.009922f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 23\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.840496f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.013016f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 24\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.486713f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.106924f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 24\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.46355f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.63213f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 24\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.09877f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.449276f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 24\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.597292f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.05313f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 24\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.051674f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.290436f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 24\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.237413f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.276487f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 25\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.406393f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.076471f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 25\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.998531f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.027508f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 25\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.69793f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.74162f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 25\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.059692f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.38826f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 25\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.66899f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.541903f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 25\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.294348f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.33956f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 26\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.32547f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.591618f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 26\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.664577f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.27103f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 26\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.806381f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.449995f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 26\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.793175f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.65526f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 26\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.744194f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.825336f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 26\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.675987f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.996181f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 27\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.006525f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.86678f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 27\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.526497f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.68143f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 27\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.859245f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.710367f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 27\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.286953f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.882233f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 27\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.619637f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.672073f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 27\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.287895f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.578857f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 28\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.271503f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.669641f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 28\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 32.422726f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.462646f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 28\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.784676f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.811617f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 28\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.556908f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.703606f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 28\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.694458f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.874252f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 28\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.163525f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.179556f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 29\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.873146f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.148922f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 29\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.183922f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.66884f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 29\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.459885f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.42384f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 29\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.21161f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.84734f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 29\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.297506f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.043884f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 29\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.238375f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.35019f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 30\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.762661f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.323244f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 30\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.615551f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.033892f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 30\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.84065f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.690865f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 30\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.567947f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.976942f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 30\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.795734f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.335669f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 30\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.091413f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.302813f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 31\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.664131f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.665878f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 31\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.703232f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.722029f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 31\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.87818f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.110176f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 31\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.085363f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.456757f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 31\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.510078f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.793577f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 31\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.59261f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.014038f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 32\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.155712f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.246342f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 32\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.622356f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.316242f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 32\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.947422f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.664661f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 32\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.411736f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.209648f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 32\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.89394f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.616825f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 32\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.753727f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.14788f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 33\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.005175f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.519016f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 33\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.618238f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.73012f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 33\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.975243f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.564869f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 33\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.257711f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.706131f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 33\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.162008f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.197008f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 33\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.73898f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 31.765541f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 34\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.676374f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.374762f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 34\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.940678f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.70539f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 34\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.975033f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.18553f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 34\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.908325f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.417723f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 34\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.258303f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.525036f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 34\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.460526f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.731668f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 35\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.309393f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.166397f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 35\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.002573f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.808641f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 35\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 30.906958f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.353008f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 35\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.911507f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.624584f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 35\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.348392f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.626465f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 35\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.920475f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.990967f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 36\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.161407f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.641216f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 36\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.016054f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.256786f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 36\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.069206f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.595907f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 36\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.558964f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.807907f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 36\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.510098f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.43351f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 36\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.373135f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.224606f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 37\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.989553f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.267601f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 37\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.674725f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.160694f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 37\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.202068f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.640324f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 37\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.977032f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.291248f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 37\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.359718f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.828138f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 37\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.482635f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.923212f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 38\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.643867f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.349394f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 38\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.819004f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.088284f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 38\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 18.471022f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 17.915966f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 38\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.273146f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.723827f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 38\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.748596f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.686745f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 38\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.305868f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.787931f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 39\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.273132f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.630884f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 39\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.225166f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.99827f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 39\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.65695f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.101845f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 39\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.454845f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.79374f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 39\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.29239f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.24427f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 39\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.975653f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.814526f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 40\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.466633f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.683496f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 40\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.652067f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.020454f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 40\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.060982f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.851532f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 40\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.826948f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.559927f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 40\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.575483f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.804356f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 40\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.241547f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.212154f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 41\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.450838f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.894348f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 41\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.159214f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.453125f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 41\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.561043f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.238836f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 41\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.646994f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.200993f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 41\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.33515f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.51118f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 41\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.36123f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.900951f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 42\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.514114f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.565336f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 42\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.115816f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.649536f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 42\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.29996f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.295158f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 42\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.94608f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.369617f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 42\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.038818f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.885021f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 42\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.111692f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.096455f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 43\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.719038f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.068813f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 43\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.08482f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.79005f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 43\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.023565f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.681047f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 43\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.564959f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.360323f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 43\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.322641f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.9206f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 43\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.822062f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.990232f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 44\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.313103f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.18895f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 44\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.501802f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.445778f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 44\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.16099f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.310482f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 44\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.877111f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.915564f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 44\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.238403f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.857944f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 44\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.569504f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.920141f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 45\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.029053f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.909576f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 45\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.206123f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.859642f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 45\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.914211f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.192644f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 45\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.062172f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.794025f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 45\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.873936f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.398401f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 45\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 17.07422f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 16.175182f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 46\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.084599f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.37204f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 46\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.350561f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.062489f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 46\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.928856f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.663717f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 46\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.360596f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.957298f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 46\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.616196f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.496971f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 46\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.380928f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.304325f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 47\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.335377f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.922512f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 47\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.877655f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.699911f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 47\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.43614f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.254108f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 47\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.86212f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.706352f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 47\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.343979f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.18057f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 47\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.994446f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.411335f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 48\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.88852f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.421764f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 48\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.639826f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.939445f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 48\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.220734f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.996864f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 48\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.02056f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.648907f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 48\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.744844f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.776127f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 48\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.17317f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.542099f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 49\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.761208f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.333237f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 49\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.338768f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.898983f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 49\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.998962f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.80355f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 49\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.325726f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.847319f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 49\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.02639f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.493822f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 49\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.685146f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.442886f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 50\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.348274f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.023598f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 50\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.31087f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.138752f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 50\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.900738f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.160217f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 50\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.373507f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.487549f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 50\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.563559f0\n", + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.946358f0\n", "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 50\n", "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.769222f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 51\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.408052f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 51\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.554232f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 51\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.177116f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 51\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.358053f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 51\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.82463f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 51\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.957832f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 52\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.096786f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 52\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.303093f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 52\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.216187f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 52\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.714031f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 52\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 29.774612f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 52\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.130646f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 53\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.937706f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 53\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.784252f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 53\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.24423f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 53\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.30219f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 53\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.690536f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 53\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.283348f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 54\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.20753f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 54\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.712158f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 54\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.816628f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 54\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.449432f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 54\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.840046f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 54\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.925455f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 55\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.76426f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 55\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.861675f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 55\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.432695f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 55\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.923695f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 55\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.43818f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 55\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.35653f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 56\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.026611f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 56\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.830933f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 56\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.0928f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 56\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.389936f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 56\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 8.432835f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 56\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.253635f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 57\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.281342f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 57\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.784367f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 57\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.119469f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 57\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.110329f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 57\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.42931f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 57\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.3354f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 58\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.20557f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 58\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.855927f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 58\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.680237f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 58\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.67761f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 58\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.310575f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 58\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.247278f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 59\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.36555f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 59\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.678894f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 59\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.489243f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 59\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.97666f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 59\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.396267f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 59\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.857048f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 60\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.645363f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 60\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.345028f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 60\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.0388f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 60\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.372253f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 60\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.957508f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 60\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.146568f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 61\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.9666f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 61\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.987667f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 61\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.835585f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 61\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.015417f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 61\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.046053f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 61\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.865223f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 62\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.974688f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 62\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.343489f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 62\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.349274f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 62\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.972279f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 62\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.305977f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 62\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.5912f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 63\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.355446f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 63\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.177032f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 63\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 10.863924f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 63\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.891338f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 63\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.208794f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 63\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.2947f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 64\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.390572f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 64\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.165335f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 64\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.150234f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 64\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.791471f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 64\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.49009f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 64\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.730213f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 65\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.899033f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 65\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.423372f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 65\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.001375f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 65\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.270048f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 65\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.136654f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 65\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.949314f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 66\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.983856f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 66\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.217213f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 66\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.731222f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 66\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.801033f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 66\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.530155f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 66\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.205227f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 67\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.18843f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 67\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.44056f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 67\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.498363f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 67\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.111303f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 67\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.864407f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 67\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.832945f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 68\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.754612f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 68\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.552414f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 68\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.798717f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 68\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.308937f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 68\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.032734f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 68\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.386208f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 69\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.889053f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 69\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.17315f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 69\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.749578f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 69\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.154047f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 69\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.899586f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 69\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.518412f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 70\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.620747f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 70\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.48816f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 70\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.395489f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 70\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.867355f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 70\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.831955f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 70\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.63542f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 71\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.006498f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 71\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.910547f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 71\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.852781f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 71\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.053795f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 71\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.566113f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 71\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.93971f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 72\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.719915f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 72\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.567732f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 72\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.067009f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 72\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.630566f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 72\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.881369f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 72\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.283709f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 73\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.977842f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 73\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.78251f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 73\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.719252f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 73\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.831766f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 73\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.329166f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 73\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.031353f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 74\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.762793f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 74\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.656246f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 74\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.323887f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 74\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.773823f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 74\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.346474f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 74\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.026167f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 75\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.21579f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 75\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.9039f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 75\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.340492f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 75\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.337955f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 75\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.05367f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 75\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.19878f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 76\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.578243f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 76\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.400549f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 76\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.024925f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 76\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.77185f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 76\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.733723f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 76\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.22491f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 77\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.374962f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 77\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.460857f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 77\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.585602f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 77\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.67676f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 77\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.2365f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 77\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.163668f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 78\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.8737f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 78\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.085178f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 78\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.73316f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 78\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.050098f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 78\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.015127f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 78\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.484646f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 79\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.067255f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 79\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.27439f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 79\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.9315f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 79\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.541557f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 79\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.650444f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 79\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.9324f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 80\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.217312f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 80\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.473713f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 80\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.991798f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 80\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.86194f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 80\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.710724f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 80\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.826077f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 81\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.596859f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 81\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.356354f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 81\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.686537f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 81\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.67141f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 81\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.553585f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 81\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.449818f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 82\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.063112f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 82\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.716024f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 82\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.03563f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 82\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.361609f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 82\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.226782f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 82\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.583712f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 83\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.711393f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 83\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.704826f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 83\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.818869f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 83\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.524006f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 83\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.562775f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 83\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.114517f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 84\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.352974f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 84\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.355661f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 84\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.83047f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 84\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.845814f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 84\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.498404f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 84\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.70013f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 85\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.050747f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 85\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.63451f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 85\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.280785f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 85\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.248508f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 85\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.548471f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 85\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.571407f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 86\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.952906f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 86\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.956108f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 86\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.773396f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 86\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.57819f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 86\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.362558f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 86\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.141186f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 87\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.48025f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 87\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.950367f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 87\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.04166f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 87\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.06808f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 87\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.057018f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 87\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.645393f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 88\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.471352f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 88\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.250923f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 88\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 19.898548f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 88\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.286873f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 88\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.45379f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 88\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.93012f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 89\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 20.791477f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 89\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.859566f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 89\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.819387f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 89\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.355679f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 89\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.759441f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 89\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.459671f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 90\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.304174f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 90\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.914288f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 90\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.268284f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 90\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.05593f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 90\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.075645f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 90\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.650444f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 91\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.8277f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 91\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.521507f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 91\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.136765f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 91\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.51986f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 91\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.753933f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 91\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.429028f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 92\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.900995f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 92\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.481503f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 92\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.095737f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 92\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.633944f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 92\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.3988f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 92\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.896637f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 93\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.8027f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 93\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.98824f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 93\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.93037f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 93\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 21.596542f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 93\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.370098f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 93\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.074085f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 94\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.232698f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 94\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.135914f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 94\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 28.110563f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 94\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.074043f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 94\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.367891f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 94\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.681921f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 95\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.592049f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 95\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.301102f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 95\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.338062f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 95\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.938211f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 95\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.074715f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 95\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.870651f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 96\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.193409f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 96\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.031347f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 96\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.18711f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 96\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.878101f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 96\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.586113f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 96\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.230448f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 97\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.917355f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 97\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.331898f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 97\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.469292f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 97\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.97321f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 97\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.545681f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 97\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.428368f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 98\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.110815f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 98\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.728079f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 98\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 26.234997f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 98\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.222769f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 98\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.157688f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 98\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.667023f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 99\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 22.824947f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 99\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.08692f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 99\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.797817f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 99\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.392517f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 99\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.88201f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 99\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.279892f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 100\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 25\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 25.646812f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 100\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 50\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.505789f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 100\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 75\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.102386f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 100\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 100\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 23.912247f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 100\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 125\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.428463f0\n", - "\u001b[36m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mtrain\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m epoch = 100\n", - "\u001b[36m\u001b[1m│ \u001b[22m\u001b[39m step = 150\n", - "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 24.633018f0\n" + "\u001b[36m\u001b[1m└ \u001b[22m\u001b[39m loss = 27.53986f0\n" ] }, { @@ -2707,7 +1510,7 @@ "EditFlowModel(\n", " Embedding(22 => 128), \u001b[90m# 2_816 parameters\u001b[39m\n", " Chain(\n", - " RandomFourierFeatures{Float32, Matrix{Float32}}(Float32[1.7281183 -8.28652 … 0.6994802 8.02288]),\n", + " RandomFourierFeatures{Float32, Matrix{Float32}}(Float32[0.37109837 7.704748 … 5.5441585 1.6017374]),\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " ),\n", " [\n", @@ -2732,12 +1535,12 @@ " NNlib.swish,\n", " ),\n", " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.95842546, 0.98741066, 0.98946583, 0.96391237, 0.99079794, 0.98914933, 0.9886823, 0.9912729, 0.9776449, 0.97661537 … 1.0056453, 0.9699813, 0.98405874, 0.98403525, 0.9776771, 0.9858879, 0.9667122, 0.96873516, 0.9970507, 0.9510425], Float32[-0.018506369, -0.004576628, -0.0052596675, -0.0013863416, -0.0020905286, -0.0082345465, -0.009565522, 0.0036397565, 0.0073073274, 0.00245158 … -0.004794393, -0.003127396, 0.004971791, 0.008037141, 0.006695991, 0.004149384, -0.007730862, 0.009864908, 0.0014894081, -0.008365696], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9961103, 0.98354983, 0.98296183, 0.9941034, 0.9855069, 0.97056925, 0.98523986, 0.98571247, 0.992952, 0.9959597 … 0.9968077, 0.974237, 0.9965491, 0.99233574, 0.975247, 0.9818705, 0.97323513, 0.9854002, 0.9814506, 1.0009559], Float32[-0.0038236545, 0.0061107413, -0.00062911137, 0.0057799933, -0.002794507, -0.001555508, -0.00058775704, -0.011436283, -0.0010510351, 0.0030899069 … 0.0054938016, 0.0007393659, -0.0042932453, -0.00040333753, 0.01101881, -0.0013433272, 0.0003267441, 0.006723721, -0.0017793853, 0.0063674543], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " ),\n", " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[1.0012316, 0.97387743, 0.9838116, 0.9914654, 0.99690056, 0.99384093, 0.9899602, 1.0077832, 0.9974476, 1.0028224 … 1.0038843, 1.000784, 0.9901355, 0.97226375, 0.99053144, 0.99020875, 0.98688054, 0.979344, 0.9902409, 0.9838954], Float32[0.002815563, -0.0024851928, -0.0083595365, -5.25621f-6, -0.0067214165, -0.002657918, -0.0013004369, 0.0034968748, 0.01953269, -0.0008888415 … -0.0023656685, -0.0054193716, -0.0116233425, 0.015501341, -0.003890949, -0.0019308609, 0.00049372844, 0.00034903453, -0.0028637475, -0.017084926], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9982594, 1.0053198, 0.9896972, 0.9885052, 1.0034368, 0.9959786, 1.0024047, 1.0017761, 1.0079848, 0.998037 … 0.99845004, 1.0012459, 1.0023891, 0.9972836, 1.0016316, 0.9928665, 0.9821593, 1.001839, 0.9991159, 0.98322225], Float32[0.0077800294, 0.006313712, 0.005019753, 0.009399522, 0.0057638027, 0.008210472, -0.00041128998, 0.009714841, 0.005229109, 0.010837439 … -0.008408365, 0.0010688071, -0.0026440201, -0.0047563454, -0.00029993433, -0.00017475362, 0.010465704, 0.0038032355, 0.008328137, 0.0069600623], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " ),\n", @@ -2764,12 +1567,12 @@ " NNlib.swish,\n", " ),\n", " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.98124874, 0.99294347, 0.97263086, 0.97624344, 0.9692242, 0.99422336, 1.0007071, 0.9877409, 0.9835757, 0.96854764 … 0.9916055, 0.9497232, 0.9818755, 0.98545647, 0.986695, 0.9832109, 0.9825076, 0.9861389, 0.9652221, 0.9917089], Float32[0.008366182, 0.0025968729, -0.0046521705, 0.0059934966, 0.0037380015, -0.006058944, -0.00213039, -0.0015994225, -0.0002880596, -0.008941856 … -0.0011073721, -0.0033712026, 0.0024713897, 0.00090915087, 0.0027050162, -0.00049480854, -0.0021957606, -0.00026154608, -0.0007733444, 0.0035458663], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.98340446, 0.99515694, 0.99383044, 0.98744017, 0.98178893, 0.99770486, 0.9998854, 0.98325014, 0.99851084, 0.97928643 … 0.9928049, 0.9935282, 0.99334264, 0.9797028, 0.9886869, 0.9849082, 0.96643585, 0.99244535, 0.9834009, 0.9998993], Float32[-0.0050134575, -0.0036863368, 0.0032099392, -0.000613435, -0.0024439872, -0.0025708228, -0.0032925045, -0.0032033226, 0.006190524, 0.0064956564 … 0.005046286, -0.0013077608, -0.0036956323, -0.0070013213, -0.0011397419, -7.354888f-5, -0.00049049803, 0.0032066598, 0.00010148762, 0.0008781409], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " ),\n", " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.98954874, 1.0064409, 1.0006205, 0.9687034, 1.0105321, 0.9992001, 1.001568, 0.9937505, 1.0011319, 0.9962604 … 1.0047686, 1.0296574, 1.003038, 0.999967, 0.9874898, 1.0177082, 0.99866545, 1.0067143, 1.0165161, 0.97980374], Float32[0.010105973, 0.0027944609, -0.013623008, 0.00015286788, 0.010491903, -0.014361129, 0.0029192131, 0.010968703, 0.02183013, -0.0075194403 … 0.0031368278, -0.0069664246, 0.005510949, 0.0029950426, -0.016416242, 0.004190883, -0.009001297, 0.0016531029, 0.00023697296, -0.016956057], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.99697554, 0.9989613, 0.98683894, 0.9949222, 0.99189675, 0.9979521, 1.0014259, 0.9904876, 0.9937987, 1.0045815 … 1.0036364, 1.0192485, 0.9905473, 0.992812, 1.007178, 1.0157473, 1.0048788, 1.0006422, 1.005701, 1.0034955], Float32[0.01035669, 0.007019663, 0.0067280596, 0.0077844895, 0.011074385, 0.005554042, 0.009326161, 0.0038617663, -0.0066101057, 0.010390683 … 0.0052756458, -0.0034369635, -0.0035258406, -0.009991266, 0.003326182, -0.00122832, 0.010301022, 0.0126599455, -0.005512634, -0.00085900724], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " ),\n", @@ -2796,12 +1599,12 @@ " NNlib.swish,\n", " ),\n", " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9971892, 1.0052998, 0.9738435, 1.0002576, 0.9848593, 0.9861847, 0.99767387, 0.9885801, 0.99154145, 0.994766 … 0.9916212, 0.9969682, 0.9904124, 0.99198806, 0.9954721, 0.9834797, 0.99912214, 0.9854371, 0.9942954, 0.9913383], Float32[0.0015207408, -0.0033681458, -0.0023985226, -0.00065797754, -0.009101785, -0.004139576, 0.00064375135, -0.0009410129, -0.007824935, 0.00028769727 … 0.0037259334, 0.0076854243, -0.005058262, 0.0020828305, -0.008041701, -0.011211128, 0.0007848889, -0.0037174162, 0.00958359, -0.012076021], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.99811625, 0.9854664, 0.9989415, 0.99436367, 1.0049703, 0.9964015, 0.9879783, 1.0056946, 1.000729, 0.99081683 … 1.0057596, 1.0069537, 0.99401844, 1.0044988, 0.9727968, 0.99472237, 0.9930699, 0.9901404, 0.99556744, 0.99798906], Float32[-0.0072035347, -0.0070618317, 0.00017180148, 0.0028987664, -0.00460521, -0.0011136559, 0.0010147326, -0.0032454734, 0.0025976172, 0.003775801 … -0.00087325997, 0.0020796831, 0.0005583409, 0.0042034183, 0.0023550594, -0.0021972822, 0.0001533411, 0.0024601675, 0.0048599523, 0.0049486584], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " ),\n", " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9926784, 1.0099522, 1.018655, 1.0246687, 1.0155983, 0.999562, 1.0058562, 1.0086799, 1.0027, 1.0159949 … 1.0171447, 1.0185226, 1.0222071, 1.0119679, 0.9941316, 0.9831888, 1.0129008, 1.0232303, 0.9945741, 1.010639], Float32[0.021637583, 0.0026361896, 0.0030154746, 0.0054475893, 0.0016284249, -0.0013797352, -0.005838183, 0.020362949, 0.0166286, 0.0027873395 … -6.395481f-5, -0.009351911, -0.0040145507, 0.0037398424, -0.0024497798, 0.0036764992, -0.0019770127, -0.007801793, -0.0034624704, -0.018143063], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[1.0113374, 1.0362657, 1.0129801, 1.0054824, 0.9959235, 1.0161504, 1.0031482, 1.0127438, 1.0027536, 1.0205426 … 1.0534416, 0.99659115, 1.0074198, 1.027664, 0.99709916, 0.9974137, 1.005346, 0.98684317, 1.0034771, 0.9989774], Float32[-0.0014052559, 0.0030515736, -0.0021614903, 0.0066673947, 0.007202584, 0.0017106866, -0.0010570075, 0.0007347914, 0.0047691455, -0.00045394935 … 0.0019431848, -0.007668013, 0.006576849, -0.0028465583, 0.0037018328, -0.007993788, 0.006362465, 0.008466869, -0.007678316, 0.004118309], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " ),\n", @@ -2828,12 +1631,12 @@ " NNlib.swish,\n", " ),\n", " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[1.0005784, 1.0023686, 0.9926611, 0.9971379, 0.9893593, 0.99703175, 0.98693585, 0.98417956, 0.99158716, 0.9840834 … 0.9798584, 1.0009283, 0.992765, 1.0134311, 0.97082436, 0.9919511, 0.99050313, 1.0135138, 1.0075364, 1.0050263], Float32[0.0028692435, 0.001397007, -0.00031375163, 0.00011770211, -0.00019967364, 0.0031852166, 0.016907748, -0.00036422213, -0.006018046, 0.0019798558 … 0.0064551155, 0.005405687, -0.0051399246, 0.010505294, -0.008053577, 0.0004768742, -0.005301881, 0.0049994923, -0.0021463423, 0.00065149594], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9981497, 1.002889, 0.98744977, 1.0060855, 0.985402, 0.98569524, 0.9988142, 0.99421, 0.97521454, 0.98611385 … 1.004141, 1.0106245, 0.9919724, 0.99938774, 0.9956309, 1.0020154, 1.014488, 1.0070881, 0.9995131, 0.9986625], Float32[-0.00467435, -0.0041207974, 0.003574141, 0.0018393839, -0.00774704, -0.0004402911, 0.009702865, -0.0013263967, -0.0007161403, 0.0039062018 … 0.00023826491, 0.0005687163, -0.005481451, -0.002329852, 0.00050594786, 0.0018227947, -0.0053469585, -0.0071314457, -0.004511974, 0.00010769644], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " ),\n", " AdaLN(\n", - " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[0.9948915, 1.0199512, 1.0060881, 1.0226755, 1.0125494, 1.0088879, 1.032922, 1.0230399, 0.9945264, 1.0315107 … 1.0220547, 1.0145272, 0.9960454, 1.0164645, 0.99917156, 1.0051632, 1.005905, 1.0241879, 0.99837464, 1.0323802], Float32[0.014390601, -0.0032132757, 0.009422892, -0.010013719, 0.0012736539, -0.009157955, 0.012012328, 0.00047939247, 0.021873204, 0.0057482067 … 0.0038961642, -0.0050933673, 0.0025382934, -0.016774157, -0.009548492, -0.004478543, -0.006396792, -0.003149633, -0.002905998, 0.0020193828], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", + " Onion.LayerNorm{Vector{Float32}, Vector{Float32}, Float32}(Float32[1.0128297, 1.0101146, 1.0129786, 0.9997293, 1.0020403, 0.99318516, 1.0349357, 1.0035822, 1.0150418, 1.0350649 … 1.0229619, 1.0016078, 1.0106664, 1.0060273, 1.0075238, 0.9961528, 1.0068473, 1.0010078, 1.0145574, 1.0092921], Float32[0.0013683313, 0.006150891, 0.0034406697, 0.005812049, 0.012213179, 0.0059094066, -0.0019328047, 0.0070142355, 0.0056433696, 0.00019984429 … 0.002948093, -0.011170231, 0.009000667, 0.0016508012, 0.007526409, -0.005769551, 0.0012698864, 0.0066841603, 0.00037845137, -0.0011874678], 1.0f-6), \u001b[90m# 256 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " Dense(128 => 128), \u001b[90m# 16_512 parameters\u001b[39m\n", " ),\n", @@ -2847,7 +1650,7 @@ "\u001b[90m # plus 3 non-trainable, 65_600 parameters, summarysize \u001b[39m5.364 MiB." ] }, - "execution_count": 9, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -2858,7 +1661,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -2867,7 +1670,7 @@ "MersenneTwister(123023)" ] }, - "execution_count": 15, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -2878,20 +1681,44 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, "outputs": [ { - "ename": "LoadError", - "evalue": "ParseError:\n\u001b[90m# Error @ \u001b[0;0m\u001b]8;;file:///home/theodor/dev/Flowfusion.jl/editflow_code/In[16]#10:59\u001b\\\u001b[90mIn[16]:10:59\u001b[0;0m\u001b]8;;\u001b\\\n# Build training strings from PM parents (the data PM was built on)\ntrain_states = [FF.DiscreteState(P.k, sample(PM; rng=rng))\u001b[48;2;120;70;70m\u001b[0;0m) for i in 1:100]\n\u001b[90m# └ ── \u001b[0;0m\u001b[91mExpected `]`\u001b[0;0m", - "output_type": "error", - "traceback": [ - "ParseError:\n\u001b[90m# Error @ \u001b[0;0m\u001b]8;;file:///home/theodor/dev/Flowfusion.jl/editflow_code/In[16]#10:59\u001b\\\u001b[90mIn[16]:10:59\u001b[0;0m\u001b]8;;\u001b\\\n# Build training strings from PM parents (the data PM was built on)\ntrain_states = [FF.DiscreteState(P.k, sample(PM; rng=rng))\u001b[48;2;120;70;70m\u001b[0;0m) for i in 1:100]\n\u001b[90m# └ ── \u001b[0;0m\u001b[91mExpected `]`\u001b[0;0m", - "", - "Stacktrace:", - " [1] top-level scope", - "\u001b[90m @\u001b[39m \u001b[90m\u001b[4mIn[16]:10\u001b[24m\u001b[39m" - ] + "data": { + "text/plain": [ + "1000-element Vector{String}:\n", + " \"QVQLVQSLAEVK\"\n", + " \"QVQLVESGGIFK\"\n", + " \"TPQLQESCPGLWVKPG\"\n", + " \"QVQLVQSGAEVKK\"\n", + " \"QQHLVQSGAEVK\"\n", + " \"QVQAVKSGGEVKPAGGKSR\"\n", + " \"QVQLVESGTGLVKLP\"\n", + " \"EVLVERGGQLVQPGNKLS\"\n", + " \"QTQLDQSGRLVKPSGTL\"\n", + " \"QFQLVQSVAA\"\n", + " \"VVQLVQSGAEVKKKPGASVVK\"\n", + " \"QVQLVESGGVLVQPGGSLV\"\n", + " \"QVQLVQSGTEVKKPGASVKSVK\"\n", + " ⋮\n", + " \"QVQLVQSGAEVKK\"\n", + " \"EVLQEGGGLVQRSL\"\n", + " \"QVQLVESDGAEVKKP\"\n", + " \"EVELMESGGGLVQPGGSL\"\n", + " \"EHHLVESGGGL\"\n", + " \"EVQLVQSGAEV\"\n", + " \"EVTLVEVGPL\"\n", + " \"QVQLLVPSGAEVKKPGS\"\n", + " \"EVQLVQDVGLVKCGGS\"\n", + " \"QVQLVQSGTEVK\"\n", + " \"QVQLVESGGTVKK\"\n", + " \"QVQLVQSGFEVKK\"" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ @@ -2908,9 +1735,216 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Build training strings from PM parents (the data PM was built on)\n", "train_states = [FF.DiscreteState(P.k, sample(PM; rng=rng)) for i in 1:100]\n", @@ -2928,210 +1962,210 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 17, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "image/svg+xml": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ], "text/html": [ - "" + "" ] }, "metadata": {}, @@ -3146,192 +2180,192 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 18, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "image/svg+xml": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ], "text/html": [ - "" + "" ] }, "metadata": {}, @@ -3339,205 +2373,213 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlgAAAGQCAIAAAD9V4nPAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nOzdd1wUx/sH8LkKHEfvSBNBVMQC9t5jN5ZojKLGEjXGEo2xJBpLNGo0xhZr7IkttpCosWPEgg3EBiodpYPAwfX9/THf7O9yd+ARvQO8z/sPXsfc7M6ze+W53Z2Z5TAMQwAAAMwVt6oDAAAAqEpIhOZr2bJlEydOlEgkb2uFx48fnzhx4p07d9iShQsXjhs3TqFQvK0mdO3du3fcuHGPHz9mS2bPnj116lTjtUhduXJl3LhxZ86cMXZDZujPP/8cN27c1atXqzoQQgjJzc2NjY2Nioq6f/++TCar6nCqr7y8vIkTJ/7www9VHch/wsBbUlJSIhAIBAJBVQeibf/+/du3b9ctDw0NJYTk5eW9rYbmzp1LCDl8+DBbEhwcTAgpLS01cA0pKSlbt269evWq4Y1OmDCBEHL+/Hm2xM3NTSQSGb6Gil27dm3r1q1JSUla5Vu3biWErFix4m019N88e/aMfpADAwPlcrnWs4MGDSKEnDx5slLrVKlUW7duPXTo0NsLs3K+/fZbQsjPP/9cVQEwDCOTyX766aeQkBAOh8N+WwoEgk6dOu3du1epVFZhbG/u1q1bW7duTUhIeIvrTE5OJoR06dLlLa7TZPimTbvvMoZhjHro85/NmTMnJydn/Pjxpm+6RYsWLi4uPB7PwPpxcXETJ06cMmVK27ZtDVykXr16nTp1cnR0/K8xvsaRI0fWrl17/PhxPz8/zXJPT89OnTr5+voaqd3Kevr06a5duz755JM3X5VSqZw4cWJQUNDQoUPffG01UW5u7vvvvx8VFSUUCvv06RMaGioSiYqKiqKjo69cuXL58uUHDx6sXLmyqsP87yIiIpYsWbJnz57AwMCqjqVaQCIEI9q5c6exm5g5c+bMmTON3Yquvn379u3b1/Tt6mVrayuRSJYsWRIeHm5lZVXV4dRsSqVyyJAhUVFRbdq0OXDggI+Pj+az6enpixYtkkqlVRUeGAMSYRUoKCg4f/58enq6UChs0aJF8+bNNZ8tLi5OSEhwcnLy8/N78eLFX3/9lZ+fHxAQ0LNnTwsLC61VqVSqCxcuPHr0SCQSderUqW7dumlpadnZ2QEBAXZ2dnRVCoWCYRj20p2VlVWDBg00V6JUKs+dO/fkyRNra+vu3bvXrl3bkK1gGCYyMjImJsbKyqpDhw7169fXrfPo0aOysrLQ0FDN80txcXH3799/+fKlnZ1drVq12rZta2dnRwhJTEykJ/qys7PZaH18fFxcXEpLSx8/fuzg4ODv75+VlXX27NnMzMxevXo1bNgwNTU1Jyenbt26NjY2Wq2XlJScPn06NTXV3d29d+/eDg4Oms8+ePBAJpOFhYVpLRIfH093PiEkNjY2KyuLEPL8+XM2pODgYEtLy9zc3JSUFC8vLzc3N8010Bc3LS3NysqqefPmzZo109ppd+/etbCwaNiwYUlJyalTp1JTUz08PHr27Onk5GTIbtfLw8OjTZs2u3bt2rhx4+zZsyuuXFpaeu3atdTU1Ly8PA8Pj44dO3p7e7PP5ubm0ldBKpWym2xvb1+nTh2VShUTEyMSibRe65ycnNTUVM1d8eTJE4lE0rhxY0LIhQsXnjx54ujoGB4eTp99+vRpTExMRkYGj8dr0KBBx44d+fzKfRFlZ2enpaW5ubl5eXm99qnU1NRbt26lpaUJhUI3N7fWrVt7enpWsPL9+/dHRkb6+PicOnWKvjM1eXl57dixIzMzU3fB2NjYmzdvvnr1ysvLq3v37s7OzprPPn/+vLCwsEGDBpaWlpGRkbGxsQKBoGPHjvTygRaGYW7dunXnzp3S0lJfX9/u3btrRUL3cKNGjTgcTmX3cFxc3IsXLwghycnJ7Etcv359kUjE1nnw4MH169cLCws9PT27d+/u6uqqG2R6evqZM2eKi4vr1q3bo0eP8vdoTVClJ2bfKcXFxYbs0pUrV1pbW2u+BF26dMnJyWErXL58mRAyZsyYTZs2CYVCtlpQUFBqaqrmqjIyMuh1PorD4cyaNWvatGmEkIiICIZhzp8/r/uKN27cmC5Ol71z505ISAj7LJ/P37Bhw2s3Nj8/v2PHjpqrnTp16pw5c0iF1whLSkr69eunFQ+fz6fXKoYNG6Yb7caNGxmGuX37NiFkyJAhGzduZPfJjz/+yJR/jfDvv/92cXFh12Nvb//7779rboK/vz+Hw9HaLtpBY9SoUfRfvcnpyZMnTDnXCLdt26aVjzt27Pjy5Uu2Aj15HhAQcPnyZc3w7OzsLl68qLmqe/fuffrpp8uXL6/4haBJKygoKCUlxcLCwsHBIT8/n31W9xrhmjVrtA4Z+Xz+zJkzVSoVrbB9+3bdTX7//fcZhnn16hUhpGnTploxbNy4kRCyZs0atqRFixaEkKtXr7Ips27dugzDFBcX656Lq1Onzt27dzVX+NprhPT90KZNG92n6Lvo+PHj9N85c+ZwudpdAg8cOFDBLm3ZsiUhZP369RXU0ZKamqr1cRCJRPStyxowYAB9o7Zv356txuFw5s2bp7W2x48fa/0+s7e314qZBvn333+zezgwMJBhmJKSkrp162ptr7+//507d9hltU7yU7du3aLPvnjxolu3bppPWVlZab641I8//qj17US/bWroNUIkwrfGkES4dOlS+pbdv3//w4cPo6Ki6I+4Nm3asJffaSL08/MTi8UrVqy4efPm+fPnu3TpQgjp168fuyqFQkE/LcOHD797925qaur+/ftdXFzor12aCPPy8s6dO+fs7Mzn88/94/r163QNNBHWrl27V69ef/755+3bt1euXGlhYcHn8+l3fXnUajX9AdirV6/o6OjU1NS9e/c6OTnRpitIhPPnzyeE9O3b98qVK6mpqQ8ePDh27Njw4cOfPn3KMMz9+/fpN2D//v3ZaNPS0ph/vvi8vb1FItGCBQvOnTt34cIF+tHVmwgFAoGLi8v48ePv37+flJS0Zs0aCwsLCwuLuLg4tpohifDy5cuDBw8mhCxevJgNSSKRMPoS4cGDB+l3Fu2GcP369f79+xNCGjVqJJVK2VeNEOLg4ODg4DBlypQLFy5cv3598uTJhBAPDw+2GsMwv/32G9H41VIeNhEyDDNjxgxCyFdffcU+q5sIv/zyy3Hjxp04ceL+/fsPHz7cv38//d5ct24drZCenn769GlCiJeXF7vJMTExTOUToY+PT48ePQ4cOHDt2rUjR44wDJOXl9e4ceMff/zxypUrT58+jYqKmjp1KpfL9fT0LC4uZhc3pLNMo0aNyD8/SliFhYVWVlZOTk4ymYxhmJMnTxJCGjZsGBERkZSUFB8ff/bs2alTp7JpUldRURE9eHr+/HkFrWsqKCig76WxY8devnz5yZMnBw4coAfZmh2OaCKsXbt2q1atjh8/fvfu3c2bN9va2hJCLl26xFZLS0tzcXHh8/nTp0+/evXqo0ePfv75ZxcXFy6Xq1mNJkLdPZyfn//aPfz333+PHDmSEPLll1+yL/GrV6/o5gcFBXE4nPDw8EuXLj158uTw4cP0FNHu3bvZ1o8dO0YIcXZ23r9/f2pq6s2bN3v06EE//kiE5u61iTA5OZnP53t4eOTm5mqW069a9sNJEyEh5K+//mLrFBUVOTg48Hg8NqkcOnSIENK6dWu1Ws1W++uvv+iyNBFStWrVEgqFuvHQRNizZ0/NNdATaxV3hqQ//YKCgjS7Kf7555+06QoSYatWrQghhYWF5a35jz/+IIRMmTJFq5wmQkLIjh07tJ7SmwgJIb1799as9v333xNCBg4cyJYYkggZhvn88881Xx2WViJUKpX0YpLmcadSqaQpYfPmzbSE7U61cOFCzbV16tSJEKJ5UHj06FEOh6ObdbRoJsKcnBxbW1tra2v2GNSQXqNpaWlisdjf358toYME6Do1VTYRtmjRwpDelfQS765du9gSQxLh6tWrCSFff/21ZuGWLVsIITNmzKD/Tp8+nRBy5syZ18bAevjwISFEKBRqfigMiX/u3LmahQkJCRYWFv7+/ux6aCJs3LgxvVRBrV+/XusN/9FHH5F/znawbty4weVyW7duzZbQRGjgHp41axYhZOfOnWzJwoULCSF79uzRqvnVV18RQqZPn65ZmJycLBKJvLy8aFtqtTooKEhrx8pkMnqsX0MTIcYRms6BAweUSuWnn36qdcLt008/JYScOnVKs7Bx48aap91tbGzatGmjUqlSUlJoSUREBCFk+vTpmpffevToofeSQwW++OILrTUQQpKSkipY5MSJE4SQadOmCQQCtrBXr15alx510at0169fr1SELHd399GjRxtYmX74WZMmTRKLxX/++aeRhoLdvn07NTU1ODhYswcNj8ejPyzoL2gWPYmtWdK9e3dCSGJiIlsyaNAgtVp99+5dw2Nwdnb+/PPPJRIJTSQG8vLyCg0NTUxMzM3NNXwpQ3zxxReGdBimGSI6OrpSKw8PDxcIBLt371apVGzhnj17CCHsm4S+327cuGH4ammyF4vFmh8KQsiff/7ZXQP7KjMMs3//fh6PN2/ePM36gYGB3bt3T0xMjI+P1yyfMWOG5uU6rY9bWVnZ0aNH7e3ttQbCtmzZMjQ09MaNG/n5+Zrls2bNert7eP/+/RwOh6ZDlq+vb58+fdLT0+/fv08IefToUXx8fEhIyHvvvcfWEQqFJhi8azzoLGM69+7do3/peDtWYWEhIYSOwmHR31ya6IFOVlZWvXr1CCEJCQmEEN3cExwcTH/VGkirIdqK3r4ArEePHhFCaFcIFofDadKkCX2qPGPHjj19+nTv3r3btWvXvXv3rl27tmzZ0vDBFUFBQYb3qtAKTywWBwQExMTEPH36tGHDhgauxHB0n2t1CyKE0NPXWq+Ih4cHPSfGYl/cNwzjiy++2Lx587Zt2z7//PM6deroVlCpVDt27Dhw4MCzZ8+ysrKUSiX7VF5enlb/jjek9zfZ06dPV65cef369YyMDJp1qMqmYVdX1549e0ZERERGRtILB0+fPr1x40ZISEiTJk1oneHDh69cuXLRokWHDx/u3bt3586dO3fuXHGvWnr9vqysTKs8JyeH9ith/jkBS8szMjKys7Pt7OyWL1+utQjbIYV+YKmKP24PHz6UyWTOzs70IoImemIzNTVVc6SQ3j387NmzFStW/Ic9nJeXl5KSIhaL16xZo/UU/f2dnJzctGlTvR9/Qgi722siJELTKSgoIIScO3fu0qVLWk85ODhofcVr9uCi6DV/tVpN/6WfVXt7e61quiUV02qItsJUOANtSUkJIUS3I5nermWahgwZEhERsWrVqmvXrv39998LFy50dXVdsmTJxIkTDQnV8K9pPp+vO7KQdk5hz2C/XeXtE/pNp9Xoa1/c/0wsFs+dO3fmzJmLFi3at2+fboVRo0b9+uuvtWrV6t27t4eHB41kz549jx8/1kyKb4Xu6xUTE9OhQ4fS0tIOHTr06dPHwcGBy+W+fPly3bp1mgd2Bho9enRERMSePXtoIqQXscaOHctWqFu37o0bNxYuXHj27NnVq1evXr1aJBJ9+umnS5YsKS8d1qpVi8PhlJWVZWZmuru7s+VjxowZM2YMIaSwsFCz+zH9FSuRSLZt26a7NgcHB629WvHHja4tJyenvLXJ5XLNEt09HBsb26FDB4lE8h/2MG29rKys4m35zx//6gyJ0HRof8I9e/YMHDjwzddGP40vXrzQ7PtO/vkdalRisZgQkpWVpdUD0JADGjr8Lj8/PzIy8tSpU/v37580aZKNjQ29NFIxrYOtCiiVSt3jm+zsbEIIeyjG5h7NXoX/ecI5+uLq7gH6Y1/r+M+opkyZsmHDhl9//VXr7Csh5M6dO7/++muTJk2uXr2q2XVZ68xteeiO0v0+NXynLVmypLi4ePfu3ZqnuM+ePbtu3ToD16CpX79+zs7OR48e3bhxo7W19f79+/l8/vDhwzXrNGrU6MSJE6WlpTdu3Dh79uzOnTtXr14tk8noxTldTk5O9erVe/z48YULF0aMGPHaGOjr7uXlVfHVBAPRtYWGhv7nywdLliwpKiratWsXTdvUuXPnDNnDtHVnZ+eKTwiV91Z/8/MZVQjXCE2nadOmhJBr1669lbXRri6RkZGahaWlpTdv3tSqKRAIaOf4t9IuIYSeWqRnelkMwxh+QcvR0XHgwIHbt2/fvXs3IYT2kKShEkLeyqGJVnhFRUVPnz61tLRkk7e7uzvDMFqfXt1TuzSk1/6apkNQaCd1zfJbt26Rf/aYaQiFwgULFqjVatohQlNsbCwhpF+/fppZsLS09MmTJ5rVeDwel8vVfRXEYrFYLNb9vtOc6LVisbGxXC5Xa5yM5uS0lSIUCocPHy6RSH777beLFy+mpqb27dtXa1gnJRKJunTpsmLFiujoaA6Hw77f9KIpZM2aNYa8D729vZ2dnZOTk9/KD9Dg4GChUBgTE/Off5DFxsZyOJwPP/xQs1B3D+t9V7u6utaqVSsrK+v58+cVB0kIuXfvntZbvVLXs6sbJELTGTlypEAg2LFjh+77jGGYyr71w8PDORzO2rVrNb+Y1qxZk5OTo1WzVq1aKpXq5cuX/y1sXbQv4oYNGzQ7nkRERGj1C9BFT6pool2u2fXUqlWLEJKWlvbmQa5evVrzg7p58+bS0tJ+/fqxg59op3A6VICSSCS6P5xphK8NKTQ01N/f//Hjx7TLPqVUKmlv1Q8++KCy8T9//nz9+vUHDhyo7IKEkFGjRtWvXz8iIoLtbUvRk8Nsfytq9erVRUVFmiU8Hs/d3T0rK0vrRBwhpHbt2llZWZpfec+fP6fjRgzh7OysVqvT09PZkoKCgrVr1xq4uC56ZLlnzx6tbjKU7vuNjkyouMPU5MmTAwIC7t27N27cuNd2reJyubRROhxQ61ndAComFouHDBkilUqXLFmi+6wha3N2dmYYRvPtWlhYqLuHy3tXf/zxx4SQ+fPnV7At9evXb9CgwaNHjzT790mlUtp5uIbCqdG377PPPtMtHD16dPPmzb/77rsvvviiVatWX3zxRfPmzV1cXJKTk+/du7d3794VK1YMGTLE8FZCQ0OnTp26fv36pk2bjhkzxtXV9fLly2fOnOnQocOVK1c0zyI2a9YsKipq2LBhAwYMsLW1dXJyogM2/rOOHTv27dv3jz/+6NOnz9dff+3h4XH58uW5c+f6+PikpqZWsGDjxo3btGnTt2/fOnXqWFtbP3r06OuvvyaEsHNa1qlTx8HBgQ72qlevnkAgaNu2bWX7wRJCBAJBXFxceHj4tGnTrK2tT5w4sXjxYisrK83vlw8//HDfvn0zZ86USqWNGzdOTEz87rvvNMcIU3TenxUrVhQUFHh6enI4nKFDh+peiOVyuWvWrBk0aNDo0aOXLl3atWvXzMzM77///s6dO2FhYaNGjarsJsTExEyfPr1x48Za5/oMwePxvv3228GDB2u9HC1btrSysqJjB/v166dUKg8cOLB+/XrdF65Zs2a///774MGDu3btKhKJ/Pz8aP/GDz/8MC4ubsiQIcuWLfPx8bl3797SpUt9fHxo163X6ty5c3R09NChQ5ctW1anTp2HDx8uWLDAxsZG99ebgcLCwkJCQq5cuWJhYeHi4tK7d2/NZ8eMGVNcXDx06NCgoCA3N7eUlJTvv/9eoVBUPIeqjY3NiRMnevbsuXfv3suXL48aNapp06a2trZ5eXnPnj3bv38/IURznpeFCxeeOnVq7969L1++HDt2bL169SQSSVJS0unTp6Ojo58+fVqpLVq9enVkZOSqVauePXv20UcfBQQEFBUVPX/+/OTJk1lZWa89n9S5c+ebN28OHTp0+fLldA8vXLhQLBbT6wKsZs2acTic9evXy+VyLy8vLpc7cOBAFxeXuXPnRkREHD58ODs7e8KECfXr1y8rK0tKSvrrr78uX77MvklWrVrVr1+/8PDwVatWtW/f/sWLF0uWLKmeMy0byvQjNt5VFffC2Lt3L622a9cuzYvwVMOGDdmZHdiZZbTWT2fN1hxqplKpvv32W3YwRqNGjS5fvkxP7GiOvc3LyxswYAA71EFrZhmtu088ePCAENK/f/+KN/bVq1c9e/Zk4+dwOLNnz37tzDIdOnTQus5nZWX17bffao7ZOn36tOalR62ZZXQjKW9mmRs3bnh4eLDrcXFxOXv2rNayWtOO9OvXj95WSXMcIcMwy5Yt0+x6U8HMMvv27dPqpNOrVy/NaYPYmWW0IqGTsi5dupQt+Q8D6rXQUZvk3+MIjxw5onleVCwW//LLL3Tg/4MHD9hqiYmJHTp0YDv00pllGIaRSqXvv/++5uv++eefb9iwgegbR5iVlaUVUklJCR0owurSpcuFCxcIIYMGDWKrVeruE3RAIdEYPsiaOXOmVh80LpcbHh5Op0SoWGZm5sSJE3UnNXRycpo1a5bma8owTG5u7ocffqg1hY2VldXo0aPZOnQMA52agKV3aGZaWppWRieE2Nrazpo1i61DxxFmZmZqha27hzt37nzx4kXy70G0DMOsXbtWc24j9vunoKBg5MiRWn25LS0thw0bprn4tm3bNDscNWzYkF6mqaHjCDkM7lD/ljAa98TR5e7uzk6+JZfLb9y48ezZM7Va7e7u3qBBA39/f7amVCp98eKFjY2N5tuUEJKTk1NcXOzh4aHV4U2pVGZmZopEIvoV3K5du6ioqMTERK0pQ9VqdVZWVllZmVAopNMwZmRkyGQyPz8/zQ+wXC5PT08XiUS62VrXrVu3YmNjLSws2rZt6+/vn5+fX1hY6Obmxn7VpqamymSygIAANv9lZ2ffvXs3MzNTrVb7+Pg0a9ZMbzdXqVRK6zg7O9va2spksoyMDGtra90rQNnZ2XR2R3a3pKSkqNXq2rVrS6XS8+fPZ2RkuLq6duvWTXcyUkJIQkJCVFSUWq1u0qRJWFgY3flisVi3C1xhYSEdxeXt7S0QCIqKirKyspydnbWmMJVIJFeuXElJSRGJRM2bN9ealpNhmKSkJIFAoNXFqbi4OCcnx9HRkd0bEonkxYsXFhYWWpM+a1EoFGlpaborJIQUFBTQjsru7u6anRXz8vJo33p3d/fOnTvb2tpmZmaWlpZ6eXlpHRDTt5ZcLtfa89HR0TExMZaWlm3btq1Tp05RUVFubq6TkxN7nETfWr6+vnrHxty5c4f+3mrYsGFYWBh9y2k2UVBQkJub6+bmZkgnI/qSEUJcXV1pNy5NJSUlt2/fTk9PLysr8/T0bNKkCT39bqDS0tLr16/TxW1tbevXrx8SElLeGJ4XL15cu3YtNzfXxsbG29u7WbNmmrtd705Wq9XJyckWFha6USUnJ9+8ebOgoMDe3p6uTTMrG7KHGYYJCQnRu4dZ9LUjhNSqVUtz/ZmZmdeuXcvOzhaLxd7e3mFhYbr7Njs7+8KFC8XFxQEBAR07dmQYJjU11crKSvMHaE2BRPhOuX//fmhoqK+vb8WXuwEAgIVrhDXY1q1b4+PjBwwY4OvrW1BQcPPmzW+++UalUtELbwAAYAgkwhpMKpWuXbtWs0uYtbX1999/T7t+AQCAIXBqtGZLS0u7detWZmamSqXy8fHp0KGD1iUrAACoGBIhAACYNQyoBwAAs4ZECAAAZg2JEAAAzBoSIQAAmDUkQgAAMGtIhAAAYNZq8ID6xYsXf/PNN1UdhSlo3Ty2BqmhkdfQsEmNjZxhGMPvumx6SqXyZX6RUq0nQjWj5nL07HABl/FwstM7EWh1QEfNVed9bmI1eBwhj8dTKBQ18WNfWcXFxXonjK7mGIaRSCS6c/VWfyUlJdbW1jXxa6KGvlXKysoEAkF5k1lXuZSUlK93nBAFtdF9SqFQsPd10VT2+Mr300bqvUtwdSCXyxmG0b23htmqpu88AIDqw9LaxqN+qG65XC7XvYclISQ96Zbxg4K35t0/nAIAAKgAEiEAAJg1JEIAADBrSIQAAGDWkAgBAMCsodcoQA0THx+/avuvCkbP6I7yevM7ifjffzO32o5PAKha+GAA1DAymYx4hfi3H6j7VHm9+VOPrFSpVEiEAHrh1CgAAJg1/EIEAHjLnsdG9+y5HVOsvV18Pv/33393dXV9+2t+62sEADBzr3Iz27dvP3r06KoO5J0ydOjQnJwcJEIAgJqhVq1aYWFhVR3FO8XKyspIa8Y1QgAAMGtIhAAAYNaMmAhVKtX169evXLkik8nKq1NUVJSYmKhQKDQL4+Pjz58/n5CQYLzYAAAAKGNdIywtLe3WrZtUKrWxsXn58mVkZKSHh4dmhcLCwtatWycmJsrl8vj4+Lp169Ly0NDQgoKCoKCg2NjYtm3bHjx4EIOfAADAeIx1RLh7925CyK1btyIjI1u0aLF69WqtClZWVrt27crPz9cq37BhQ1JS0pkzZx4/fhwVFXXy5EkjRQgAAECMlwiPHj06fPhwOoxm5MiRR48e1apgYWHRqlUr3V5Abdu2pQ/s7e29vLwKCwuNFCEAgMkM+2gkx1T++OOPqt7c/5HL5VUdgkGMddYxPT3d19eXPvb19c3IyFCr1VxuJfJuZGTk8+fPe/XqVV4FhmEOHz7MrjMwMLBx48ZvEnO1pVar1Wp1VUdRaQzD1NDIadjVdrixWq0mDEPHRGthyisn1fq1UP+jqgPRT61Wl7tjyyknOmWFRcUf/nA8qEM/IwT4L39+E15UVKRZcvv27VWrVo0ePbpPnz60ZOLEiTNnzgwKCtK7hpycnHv37vXo0ePNg3Fzc7tz546/v/+br4r6D+8TQ/KOsRKhTCZjJ/8VCoUqlUqhUFhYWBi4+LNnz0aMGLF582ZPT88Kqh0+fJj9tmrbtm15r2tNp7kzaxCGYaRSaU28xCuVSnk8XrVNhHK5XKlSKZVK3aeUSqXej71KpZJKpfq/sqsBqVRanadClclkqkrucHV12tUZGRnHjww9CLIAACAASURBVB+nuY1+k0RERIwaNaq8L8zHjx/PmjUrLi7OtGG+HsMwcrlcKpVWaimhUPjat5ax3nnu7u55eXn0cW5urqOjo+FZMDk5uVu3bt98882wYcMqqMbhcH777bdKHWXWUCqVSiQSVXUUlUZ/LNfEyNVqtUgkqraJ0NLSks/n6/1txDCM3nI+jy8SiQz/DJoYh8MRCATVNhFaWVlVdodzudXrzVOvXj1bW9sdO3ZMnjxZszwtLe2XX3558uSJk5NTeHh4kyZNVCrV1q1bMzMz586dSwhZtmzZL7/8EhwcTCcHePDgwY0bN8aPH//q1avVq1ePGDHip59+8vf3nzx58r59+27fvs0wTLdu3T744ANjbAWHw7G0tDTGV4qxskirVq0iIyPp48uXL7du3drABdPS0rp16zZ79uwJEyYYKTYAALPC4XBWrFixdOlSiUSiWR4XF2dlZfXhhx8GBgZ27949Pj6ew+EEBQVZWVmFhYWFhYVxOJxjx46xR4fx8fEHDx4khBQXF69cuXLq1KmtWrUKCQkpKCh4+vRpnz59evTosXz58k2bNlXBRr4BY/0EmzJlSrNmzYKCguzt7VesWHHs2DFaHhAQsGrVqkGDBhFCNmzYQF+V7du3Ozs7z5gxw8LColu3biKRqKSkZOXKlYSQtm3btmvXzkhBAgCYifbt2zdu3Hj9+vXz5s1jC3v37k0IKSoqqlu37q1bt44dOzZv3rxOnTodOXLktUd1CoViw4YN9erVo/+uXLlSJpNlZmbOmjVry5YtU6ZMMd62vHXGSoSBgYGRkZE7duyQyWTHjx/v1KkTLf/ss8/YHUf++Z2iueD48eOr7TVzAICaa+XKlZ07d544cSJbcv369bFjx4pEIkdHx6SkpEqddRQKhexVxsLCwg8//PDZs2d+fn4lJSXZ2dlvOXQjM+JJ+SZNmmzcuFGrcMaMGezjqVOn6i41e/Zs44UEAGC2GjVq1L179++//54tmTlz5qJFi2hvjBkzZtAOQVpXxwUCATv5V3FxMVvO5/PZmhs3bnRzcztz5gwh5OzZs5q5tkZ493uaAAAAtXTp0p9++onNZxKJhHahevHixaFDh2ihk5NTdnY2OzVmYGDglStXCCFSqXTv3r16VyuRSGinIYVCUeMuEBIkQgAA8xEYGDh8+PCSkhL678KFC8eNG9eqVavevXt37dqVFtavX79Xr1516tRxdHRUKBRTpkyJjo4OCgoKDQ1t2LCh3tVOnDjx0qVLTZs2bdiwYUBAAFsuEAiqbe9rTdW0vzIAwLuEy+VE71sd/9cvxm4oNS6aM+Jfw/YHDBgwYMAA9t8tW7Zs2bKFPh4yZEjfvn2zs7O9vLzYoWgcDofOkUnVqlXryZMn6enpbm5uQqGQFnp5eWl2QPXz80tISMjIyHB1dbW0tFyzZg0trykXC5EIAQCMbtWypU+ePDFJU0O7d+9ueG1LS0sfH5+K63A4HG9v74rr8Hi8166n2kIiBAAwuqCgIC8vL9O0ZW9vb5qG3hlIhAAARjdq5Mg///yTz+cZu6HSMunhI0c0z4XWREqlsrS01NbW1jTNIRECABhdqaR4+xef9GoVauyGPvlhh9b0MdTt27fXrVt3//59CwuLoKCgjz/+uEuXLsYOhhUbG/vq1asOHToYWP/69etTpky5f/++UaNiodcoAMA7LiIiokuXLvXq1du1a9eOHTs6d+48YcIElUplsgD++uuvffv2may5ysIRIcB/oVarK3uzTKFQKBaL37xphmFUCrlSVqb7lFIu5zJ6vt1UKj13TgAzoVQqJ0+evGTJEnY+k0aNGg0fPpztJnr69OkTJ06oVKqhQ4fSuy9dv349JSWFy+UeO3bMy8tr/vz5jo6OhBCGYXbt2nXlyhWxWDxp0iQ6muK3335zdHS8e/dudHT0mjVr6JDE9PR0Hx+fqVOn+vr6JiUlnT59Oj8/f+7cubVq1aJTqfz666/nz58XCoVjx45t0aIFjeTo0aMnT550dnZu3769KXcREiHAf3H06NGt69bxeZU4p6IgnHOXLr35/VKSkpLSz/4iibuq+5RKrebpW39W0iOFYma1vfsEGNX9+/czMjJGjRqlWcjeFH3z5s1bt25dunQpIeSzzz5bvXp1//7979y5s3Tp0pEjR44bN2779u3jx4+n80V/8sknmZmZn3/+eVpaWvfu3f/++++AgIDTp0+fPn36s88++/jjj0Ui0YMHD1q2bDlo0KCoqKj27ds/fvzYwcEhMDAwPT29W7duNjY2hJC5c+dGR0fPmzcvLy9v0KBBv//+e2ho6IEDB+bPn79+/XqJRDJnzhxLS0uT7SIkQoD/QiaT1ff16da1p+GLrPt5S2VvT62XUqkMdBL37NRK9ymVSsXj6emOsSk5DlP4mq3MzEw6myj9d/HixS9evCCEzJ49OyAgYMGCBZcuXQoJCSH/zAvTv39/Qoi3tzcdDujv70/vwZScnHz48OHMzEyaRJ89e7Zjxw46WXS3bt3mz59P1z9u3Di5XJ6VleXp6fnbb7/duHGja9euAQEB9A5NhJCCgoJ169ZlZGTQkDIzM7du3bp169a1a9euWLGiX79+hJD09PTyZrExBiRCAIB3ma2tbVlZWWlpKZ1TOzg42MPD44svvhg5cqSNjU1eXt6YMWPo/C8ymYw9bRAYGEgfODs7v3r1Sq1WP378WKlUsicti4qK2McNGjRgm9u6devy5cvr1q3r4OCQkZHx8uVLrXiePn2qVqvpOVhCiEQiqV+/PiHk+fPnNB8TQho3bmyEPVEuJEIAgHdZkyZNRCLRuXPn6JiKIUOGEEK+/vprQoidnR2Pxzt16pSbm5vWUrqnLpycnBwdHW/fvq3bBHtTZZlMNn369GfPntFBky1atGAYhhDC4XDoA7oeoVB48+ZNrbMX9vb2BQUF9HF+fv4bbXMlodcoAMC7TCwWz5s3b9q0aX///TctycrKksvlhBBLS8sBAwZ888039P4SMpnswYMH5a2ncePG1tbW7JzaBQUFiYmJWnVUKpVKpaJ3sbhw4cKdO3douYuLS3JyMj0/X7t27fr16y9fvpymxuLi4oSEBEJInz59Nm7cqFarZTIZOwmcaSARAgC84+bPn0/Phdra2np5ebVp02bmzJmhoaGEkK1bt7569crX17dhw4b+/v7nz58nhFhaWlpbW9NlORyOg4MDIcTCwuL48eOHDx/29fWtV69eaGhofHw8IUQkErEdW0Qi0eLFi+ns2z/++GOfPn3oudaBAwcKhcLatWv379+fy+UePnw4KirKx8cnODi4QYMG9+7dI4QsWrQoLy/Pz88vJCSkRYsWJhtNT3BqFADABDhc7rrjZw//ree84tt1+3HCQJ2zmhwOZ+rUqVOnTi0sLBQKhZo34HV2dj5w4IBSqSwuLqYJjxAyfvz48ePH08e2trbsicr69etHRkbKZDKZTMYmqg0bNmi2NX/+/FmzZkmlUjs7O7bQzs7u1KlT7L9+fn5nzpyRy+VlZWVsNUdHx7Nnz5aUlAiFQnZ2b9NAIgQAMLqV36+Ji4szQUMjebwKJt0ubxpSPp/PZsHXsrCwqHgozmsrUHoT3lsZa1tZSIQAAEZXr169evXqVXUUoB+uEQIAgFlDIgQAALOGRAgAAGYNiRAAAMwaEiEAAJg19BoFAHjLuDzB4sWLV65cWdWBvFOKi4vZm2a8XUiEAABvWaMO7/26eY2Li0tVB6KfXC5nGKbG3ZaLx+MZaboZJEIAgLeMy+Xa2dkZPkTdxGpoIjQeJEKAKpCamlpcXFypRby8vDTnrKoScrn86dOnlVqEz+fXrVuX3uUHoHpCIgSoAlt+OZotcOXxBQbWLynIHdUu8L3yp84yjcTExO9/PWPh4m34IurM+LVff14l82YBGAiJEKAKKNTEuVlPSxv9Ez/qSo2JYojMqCEZgmEYvqOnR/vBhi+SdmIteyM6gOoJiRDM194DR9Jz9Nz/Uy6XC4RCPefyOJyB3drTu2m/oaSHsaqsjXyhpYH1X2WmJrdv9ObtAoAuJEIwX7efJHHCBupmI4VCIRDoOWn58sm9NllZbyURyguyugfVEdsY2hf8YW5xQYFJ79kNYD6QCMGsiR3dBFbWWoVyuVzv7dDy0569xabtbGzsyrknji5LdPADMBrMLAMAAGYNiRAAAMwaEiEAAJg1JEIAADBrSIQAAGDWkAgBAMCsIRECAIBZQyIEAACzZsQB9RcuXLhy5YqPj8+IESMsLbUn71Cr1QkJCffu3ROLxf369WPLGYY5evRoXFxcgwYNPvjgAy4XqRoAAIzIWGnmp59+GjNmjJWV1aFDh3r16qU76+53333XqVOnb7755ocfftAsnzFjxpIlS0Qi0apVqyZPnmyk8AAAACijJEKlUrl8+fKdO3fOnTs3IiIiISEhMjJSq84XX3yRmZk5c+ZMzcLs7Oxt27ZFRETMmTPn1KlTe/fuTU9PN0aEAAAAlFESYXx8fF5eXufOnQkhFhYWXbp0uXDhglYdvTdHvnr1ap06dXx9fQkhbm5ujRo1unz5sjEiBAAAoIxyjfDly5dOTk58/v9W7u7u/uLFCwMXdHNzY/+teEGGYWbPns3e+To0NHTQoEFvEHX1JZVK9d4MoZpjGEYqlbJvg2pIpVIplUqOUqlVrlQq9V6cVqlUcrlaKpUSQhQKBcMwarXa8OY0d4harVarK7E4o2ZUSiXbtLqcptVqtd57wdOm9c4kXikymYzuNMMXUSlVr30DS6VSlUpVbd8qFWx1BW8VmUxGX69qSC6XMwxjJveJFAgEPB6v4jpGeedxuVzNT6nhb3HdBSveAEdHR/Zj7+Li8tqtraF4PF5N3DSGYap55BwOh8vl6n6RcblcDoejm1E4hHC5XLpFXC6XED11KmpO86XkcDgcYvjiHA7hcP6/aQ7Rv2z55Zy38lrweDy60wxfhMN5fdO8f7xheEZSwVaXV87lcNi3SjXE4/Hox7OqAzEFQz5lRkmEHh4eeXl57L1sXr58GRQUZMiCnp6eL1++ZP99+fKlp6dneZU5HM68efPMoVupQCCooUeE1Txy7j90y/V+R3B5PD6fQ7eIx+NVKpMRQgiHIxAI6I/C/2VawxfncLg8rkbT+pflcLn618l5O+8iPp+vd49VgIZdcdNKpZLdM9VQBVvN4/H0J0ju67e6CtHDwWobnukZJYsEBQV5e3ufOnWKEFJcXHz+/PnevXsTQoqKimJiYipYsGPHjmlpaY8ePSKEJCUlPX78uGvXrsaIEAAAgDLWqdGlS5d+8sknFy9ejIqK6tixY4sWLQghUVFRH330UUFBAX28aNGi9PT0rKys7t27d+rU6auvvrK3t587d27v3r0HDhwYERHx+eefu7q6GiNCAAAAyljnIoYPH96oUaNr16717NmzZ8+etLBFixYnTpygjwMDA+fMmcPWZ/vILFiwoFu3bnFxcYMHD27Xrp2RwgMA03vy5Elubq5uuUwm4/P5ek9H+/r6ent7Gz80MGtGPCkfHBwcHBysWeLk5NSxY0f62NXVtVu3bnoXbN26devWrY0XGABUiUt/nrR79dJaZ54plVrF5XA4HO0rNdmFr3Kbd/L2HmaqAMFMVdOr0wDwTgqr6+/u5KBVSAch6PY6uf88Jc9UgYE5e/e7XAIAAFQAiRAAAMwaEiEAAJg1JEIAADBrSIQAAGDWkAgBAMCsIRECAIBZwzhCADCUQqEoyEy3SHxk+CKv8nLM5HY/UHMhEQKAodLS0hQPLgsUlRjmXvDwZmlpqa2trfGiAnhDSIQAUAmuYlHnRg0Mr/8sLhpHhFDN4RohAACYNSRCAAAwazg1CgDvvvz8/MLCwkot4uLiYmNjY6R4oFpBIgSAd9+JQwckac8shUID65eWSWs1aTlk+EdGjQqqCSRCAHj3MUpF5yAfb1dnA+s/TklPUyuNGhJUH7hGCAAAZg2JEAAAzBoSIQAAmDUkQgAAMGtIhAAAYNaQCAEAwKwhEQIAgFlDIgQAALOGRAgAAGYNiRAAAMwaplgD85WVnlIQfY4vtNQqVyoVfL5At3728we5DnVMEhoAmA4SIZivouT4NnZWAgvtRKhSq3lcPSdLhGmP09MtTBIaAJgOEiGYtQC/2iKx9q12VCoVj8fTrVyU88IkQQGASSERAoCJ3LwdI7Mh9tYirXJGreZwOITD0SpPyc5T+pa+/8EwUwUIZgqJEABMpEyhFPk0dfD00ipXq9UcDoejkwgz7t+VKHAvJDA69BoFAACzhkQIAABmDYkQAADMGhIhAACYNSRCAAAwa0iEAABg1pAIAQDArCERAgCAWUMiBAAAs2asRKhQKJYvX/7ee++NHj366dOneuv8/vvv/fv379+//++//84WJiQkTJo0qUePHuPGjYuNjTVSeAAAAJSxEuHXX38dERExf/58Pz+/zp07S6VSrQpXr14dPXr06NGjx4wZM2bMmKtXrxJCysrKOnXq5Ojo+N1339WtW7dTp045OTlGihAAAIAYaa7RsrKybdu2nT9/PiwsrGPHjhEREb/99tvIkSM166xfv37atGmDBw8mhNy/f3/9+vXt2rV7/vx5Tk7Ot99+y+Vyw8LC1q1bFxcX16VLF2MECQAAQIx0RJiYmCiVSkNDQ+m/rVu3vnPnjladu3fvtm7dmj5u06bN3bt3CSEBAQHe3t4HDx6Uy+WnT59mGKZJkybGiBAAAICq6IgwKyvr5cuXKpVKszAsLOy1K83KynJwcGDnkndyctK9TJiVleXo6EgfOzo6ZmZmEkIsLS137NgxcODAcePGcTicffv2sXV0MQwTFhbGttK3b98vv/zytbHVRBKJRHdi/uqPYZjS0tKqjqIiarVKrVZpvcMJIWqdkn/qMzKZrKSkhBAilUrVarXushU2py4pKeHz+YQQlep/bRu4LKNiFHL5a5sub4VqtVoikXD13W24UsrKyphKbzUjkUho5CqVSqV3h5dz9wlGrVLIFXTZNySTyRQKjlwuN7C+QqGQSv/3WkskEoVCoXfZ8laoVCjYra6G5HI5wzAKhaKqAzEFS0tL+qGrgP6nHzx4MHHixGvXruk+xTDMaxsWi8VlZWXsv6Wlpba2thXUKS0ttbGxIYQkJSUNHjz45MmTnTp1unfvXvfu3WvXrs0eWWrhcDjbtm1jP9seHh5isfi1sdVEDMPUxE1jGIbD4VTnyLlcHpfL03sPXr2FXC7HwsKCbpGlpSWXy9VbrfzmuGKxmH4mebz/tW3gshweRyAUGtJ0OZFzra2t3/y1sLKy4lR6qzls0zwej6dvh3P+oV3O5QkEgrfyFrKwsBAIGKFQaGB9gUBgafm/19ra2logEJS3rN5yvkDwVna4kdBEaGFhUdWBVBf6E+Hw4cNzc3PXr19ft27dSr3pKW9v76Kiory8PCcnJ0JIYmKi7nGkj49PYmJix44dCSFJSUk+Pj6EkMjISH9//06dOhFCmjZt2qpVq/Pnz5eXCAkhYWFhb/4jFwAAzJmeRPjq1auHDx8eP358wIAB/22lHh4e7du33759+9y5c5OTk8+fP79y5UpCSFpaWkRExKeffkoIGTZs2M6dO8PDwwkhO3fuHDZsGCHE39//2bNnL1688PT0LCwsjImJGTNmzH/eNgAAgNfSczhFT1B4enq+yXp//PHHn376KSwsrFmzZnPmzAkMDCSExMfHz549m1aYOHGihYVFUFBQUFCQUCicNGkSIaRDhw5jx45t1KhRhw4d6tat261bt0GDBr1JGAAAABXTc0Roa2vbp0+fiIiI5s2b/+f1NmnS5Pnz50+ePPH09KQnSAkhXbp0ycvLo4+tra3Pnz+fmJhICPH392cXXLt27TfffJORkeHh4VFBTxkAAIC3Qv81whkzZowdOzY/P79Xr17u7u6aTxnSa5QSCAQhISGaJVwu19LSUrNEMwWy7O3t7e3tDWwFAADgTehPhCNGjMjKytq0adOmTZu0njKk1ygAVFvFxcXFxcWVWsTJyamm9zCUyWQlJYpiK0O3QiKRyC3MYnQBkPIS4eHDhw0fcAMANcje7VsUuS/5BvcGl5SVNe7Sq2fvPkaNythuxzyQ2fBcHQw91ZSSmZVrWzzCqDFBtaE/EXbo0MHEcQCAaaikZf0aBTjb2RhY/3b8c1llRtBXTwq1WuhaR+yr51qMXnz5fRUOBsxGRePt8/PzHz58mJ6e7uHhUb9+fTc3N5OFBQAAYBr6E6FKpZo9e/amTZvYE6Q8Hi88PPynn36ysrIyYXgAAADGpT8RLly48Mcffxw5cuQHH3zg6emZk5MTERGxfft2QsiuXbtMGyEAACGEaE7caAgul1vT+/iAaehJhEqlctOmTfPnz//222/Zwp49ewYHB0+bNm3NmjUY3gcAJpacnLxr/RoBURu+iIIrmLVwie5ExwBa9CTC7OzsV69eDR06VKt82LBhU6ZMSUxMRCIEABNTKpXetpYftGxk+CI7Iu8olUrjhQTvDD1TrNnY2HC53OTkZK1yWmJnZ2f8qAAAAExEfyLs2LHj1KlTo6Oj2cJHjx6NGzeuXr16AQEBJgwPAADAuPR3ltm8eXPnzp1btmzp6+tLO8s8f/7czs7u9OnTNfEOsQAAAOXRfzO/oKCgBw8erFixIiQkRKlUBgYGfvPNN48ePWrVqpWJ4wMAADCqcgfUOzo6zpkzZ86cOaaMBgAAwMRwe3cAADBr/39E+Oeff3777beTJ08eNWpUnz598vPz9S5w/fp1U8UGAABgdP+fCK2srNzc3KytrQkhLi4uAoGg6qICAAAwkf9PhF26dOnSpQt9vHv37qoJBwAAwLT0XyPct29fVlaWVmFWVta2bduMHxIAAIDp6E+Es2fPfv78uVZhYmLixIkTjR8SAACA6VSi16hEIqFXEAEAAN4Z/xpHGBcXRzuFlpWVnTx58sGDB+xTSqXy119/DQoKMnWAAAAAxvSvRHj+/PmZM2fSx6tWrdKq6ufn9/PPP5soLgAAAJP4VyIcO3bsgAEDCCEtW7bcvHlzaGgo+5Srq6tYLDZ1dAAAAEb2r0RoZ2dnZ2cnk8kmT55cp04df3//qgoLAADANPR0lsnLy1u6dKlMJjN9NAAAACamJxG6urra29tnZmaaPhoAAAAT05MI+Xz+vHnzFi9enJ2dbfqAAAAATEn/bZiePn2amprq7+/fsmVLJycnzacOHz5sksAAAABMQX8iTElJqV27NiHk1atXr169Mm1IAAAApqM/EZ49e9bEcQAAAFQJ3JgXAADMmv4jQkJIXl7ezz//HBMTk56e7u7u3rBhw/Hjx3t6epoyOAAAAGPTf0QYHx/fqFGjOXPmXL16VSaT3b59e9GiRcHBwTdv3jRxfAAAAEal/4hw0qRJXC43KiqqTZs2tCQuLu6jjz4aM2bMo0ePOByOCSMEACAMw5SVlhUXFxu+iFQqNV488C7RkwiLi4uvXLly7NgxNgsSQkJCQnbt2tW8efNnz54FBgaaMEIAAJKenn7nYYIjv9yrObruPHhSVFTk6OhovKjg3aA/EarVajp8QhOdehSjKQDA9NRqNbGwFgeEvr7qP5jbD1UqlfFCgneG/inWbG1tjxw5olV+5MgRHo+HmbgBAOBdoueIkM/nT5kyZdmyZWlpaUOHDvXw8MjJyfnjjz+2bdsWHh6O8wwAAPAu0X/CfenSpWVlZT/99NOePXtoCY/HCw8P37RpkwljAwAAMDr9iZDH461du/arr766efNmfn6+nZ1d8+bNPTw8TBwcAACAsVU0s4yzs3OfPn3Cw8P79+9f2SyYmpratWtXW1vbBg0aXLx4UbeCSqWaNm2ak5OTm5vbsmXL2PKysrKpU6e6urqKxeIePXpUqlEAAIDKKrcvcmZm5tatW2NiYjIyMujMMp988omfn5+B6/3kk08aNmx4+vTpiIiIIUOGpKWlWVtba1bYunVrZGRkfHx8SUlJ+/btmzZt2rt3b0LI2LFji4qKoqOj3dzcbt++/QabBgAA8Hr6jwijo6ODg4OXLFmSmJhob2+fkZGxevXq4ODgM2fOGLLStLS0ixcvLliwQCgUDh482N/f/9ixY1p1fv7555kzZzo7O/v5+U2YMGHnzp2EkISEhBMnTuzevdvPz8/Kyqp9+/ZvuHkAAAAV058IP/74Y3d390ePHsXGxp49e/bOnTvPnz8PCwsbPXq0XC5/7UqfPn3q7u7u7OxM/23YsGFCQoJWnYSEhJCQEPo4JCSEVoiNja1Xr966desaNGjQvn37v/76679vGQAAgAH0nBrNysp69OjRxYsXg4KC2EJvb+8dO3YEBQU9fPiwadOmFa80Pz9fLBaz/9rZ2eXm5mpWkMvlJSUlNjY29F9bW1ta4eXLl/fv3+/Vq9fVq1cvX748aNCg2NjYgIAAva2o1Woej8f+O378+LVr175mc2smiURSE6e1YximtLS0qqOoiFqtUqtVumOu1eWMwlarGZlMVlJSQgiRSqVqtbpS47XVanVJSQmfzyeEqFT/a9vAZRkVo5DLX9t0eStUq9USiYTL5RJC5AqFQiE35BctpVQoysrKaNNlZWVMpbeakUgkdHGVSqXSu8PVag6Ho/smZ9QqhVzBNl3ZHa5SM6WlpWzTaoYxfHG1Wq1QKOmyKSkpT/468CLmmt5qdK9qKXqZ9KJva63rQdWHXC5nGEahUFR1IKZgaWnJf92ERHqeFolEXC7XxcVFq5we4Rny0jo5OWlOCVhYWOjr66tZQSgU2tjYFBUV0X9fvXpFm3N0dOTz+YsXLxYIBIMGDdqwYcOZM2c+++wzva1wuVyFQqH3XfiOYRhG84dFTcEwDIfDqc6Rc7k8Lpen+XOKpbeQy+VYWFjQLbK0tORyuXqrld8cVywW088kj/e/tg1clsPjCIRCQ5ouJ3KutbU1DUvaQgAAIABJREFUXVwoEAgEQqFQaGDTfIHAysqKLmtlZcWp9FZz2KZ5PB5P3w7n/EO7nMsTCARs05Xd4TwuRyQSsU1zORzDF+dyuQIBny7L5/N9bK2G9uigW02lUuld5/4jGWzk1RBNhBYWFlUdSHWhJ4vY2Nj06dNn8+bNWuVbtmwJDQ2tW7fua1caGBiYlZWVk5ND/42Li9NdKigoKC4uTqtCvXr1OBwOm9t4PJ5ara7M5gAAAFSO/sOpwYMHHzx4sF27dj/88MOvv/66bt26nj17Ll++fOTIkUf+kZSUVN5Kvby8unbtunjx4rKyskOHDqWkpAwcOJAQcvPmzUmTJtE648aN++GHHzIzM589e7Z9+/Zx48YRQpo1a9awYcPVq1crlcpLly7duHHjvffeM8JWAwAA/I/+M6dz5szJz8+PioqKiorSLJ85cyb7ePv27ePHjy9vvTt27JgwYUKtWrW8vb2PHz9OT6iWlJQkJyfTChMmTHj27FmTJk0EAsH06dN79uxJyw8dOjRp0qRVq1b5+PgcPHhQ8zolAADAW6c/Ed68efO1V5V1LyJqqlWr1qlTp7QKu3bt2rVrV/qYx+OtXr169erVWnXq1Klz7ty5ipsGAAB4W/QnQq2+LQAAAO+qijqVJiQkxMTEpKene3h4NGzYkB32BwAA8M7QnwilUunHH3988OBBzcL33nvvwIEDDg4OJgkMAADAFPT3Gp01a9Zvv/02e/bsO3fuZGRkxMbGLl269OrVq2PHjjVxfAAAAEal54hQLpfv3r17+fLls2fPpiWenp6NGjWqXbt2eHh4dna2q6uraYMEAAAwFj1HhLm5uaWlpb169dIq7927N8MwKSkpJgkMAADAFPQkQnt7ez6f/+DBA61yWlLxqAkAAICaRU8iFIlEPXv2nDp16smTJ9kZzi5dujRmzJjQ0FDDb0kIAABQ/envLLN582ZnZ+f333/f2tq6du3a1tbWXbp0kcvl+/btM3F8AAAARqV/+ISXl9e9e/cOHz585cqVoqIikUjUunXrjz76iL1xEgAAwLtBTyIsKCgYOnTookWLRo0aNWrUKNPHBAAAYDJ6To2q1erz589X6r5fAAAANZSeROjk5BQSEnL9+nXTRwMAAGBi+q8R7ty5c9iwYRYWFv379/f09DSHu8ADAIB50p/h+vbtm5iYOGXKFG9vbx6Px9Fg4vgAAACMSv8R4ddffy2RSEwcCgAAgOnpT4SfffaZieMAAACoEtqJMDY2dsuWLQkJCa6urr169cLwCQAAeLf9KxHev3+/TZs2paWlYrFYIpEcPHgwJSVlwYIFVRUcAACAsf2rs8zatWsFAsG1a9eKi4uzs7O7dOny/fffK5XKqgoOAADA2P6VCB8/fjxmzJjWrVsTQpydnZctW1ZcXJyWllZFsQEAABjdvxJhVlaWj48P+6+vry8hJDMz09RBAQAAmMq/EiHDMJojBeljhmFMHRQAAICpaPca3bJly6lTp+hjuVxOCJkxY4adnR1b4dy5cyYLDgAAwNj+lQh9fHwyMjISExPZEn9//7y8vLy8PJMHBgAAYAr/SoRXrlypqjgAAACqBGbTBgAAs4ZECAAAZg2JEAAAzBoSIQAAmDUkQgAAMGtIhAAAYNaQCAEAwKwhEQIAgFlDIgQAALOGRAgAAGYNiRAAAMwaEiEAAJg1JEIAADBrSIQAAGDWjJgIi4uL79y5k5+fX14FlUoVFxeXlJSk+5RSqSwoKFAoFMYLDwAAgBgvEUZERNSuXXvq1KmBgYG7d+/WrZCRkdGwYcPw8PAOHTqMGDFCrVZrPjtr1ixHR8dLly4ZKTwAAADKKIlQqVR++umn27dvv3bt2qlTp6ZNm1ZcXKxVZ+nSpS1btoyJiXn8+HF0dPQff/zBPnX9+vW4uLhatWoZIzYAAABNRkmE165dk8vlAwYMIIS0bNnSz8/v1KlTWnUOHTo0YcIEQohYLP7www8PHTpEy2Uy2aeffrpp0yYOh2OM2AAAADTxjbHSlJQUPz8/Lvd/Wdbf3z8lJUWzQlFRUWFhob+/P1vh8uXL9PHChQuHDBlSv359Qxq6cOECmy8DAwN9fX3fSvxQU8hksoyMjEotIhKJ3N3djRQPANRERkmEpaWlFhYW7L9WVlYSiUSzAv3X0tKS/mtpaVlSUkIIuXfv3rlz527evGlIKwzDLF++nE2EHTt2nDlz5luJv7qhO6fGYRimtLSUYRjjNXH79u1tp6Ot7JwMD8miKP37BV/Qf1VqlVqtUqlUWtVUKhVhGKJzTkKtVstkMnqeXyqVqtVq3WUroFari4uL+Xw+IUSpUqkqszijYuQyOW26rKysvKbLW6FarS4pKaEfFrlcrlDI5XK5gU0rFYqysjLadGlpKVPJrVapmZKSErq4SqVS6dvhapWKw+XqngRi1Cq5XPHara6gaYlEwjatZhjDF1er1QqFQmOr9S9b3gpVjJptuhqSy+UMwxj+HqjRLC0tBQJBxXWMkgjd3NwKCgrYf/Py8rR+g7u4uHC53Pz8fAcHB0JIfn4+rfDll18GBQX98MMPhJDi4uLDhw+LRKJ27drpbYXD4Vy4cIE97ny32djYVHUIlcYwDJfLFYvFxmvC0tLSyq+xT8vuhoakVmX8toLdmTwuj8vl8Xg83Zp6C7lcroWFBV3c0tKSy+XqrVYeLpdrY2NDEyGfx+NVZnEOjyO0ENKmraysKmi6vMjFYjFdXCgUCgRCoVBoYNN8gcDKyoouKxKJOJXcah6XwzbN4/F4+nY45x/a5VyeUCAwZKvLa9ra2pptmsvhGL44l8sV/NO0SCTicMtdVv/7h8Nlm66GaCLUPFwxc0ZJhE2bNk1ISMjLy3NyclIoFLdu3Vq2bNm/WuXzmzRpEhUVVadOHUJIVFRUWFgYIeT9999PS0ujSZT+fC4rKzNGhPBuePnyZfr1y5KMZ4YuwDBFCQ+NGREA1DxGSYS+vr79+vX7+OOPP//88z179gQHBzdv3pwQsm/fvn379p09e5YQMn369K+//trZ2TkpKenUqVOxsbGEkClTprAr+eWXX8aNG9e9u6E/9sEM5eXl1VFkNbU19NqwWq06klO5a4oA8M4zSiIkhOzevfu7775btWpV/fr1T548SQtr167dtWtX+njUqFGEkK1bt9rY2Jw7d063n8uIESO8vLyMFB68M6wsLd1cXAysrFYpjRoMANRExkqEYrFY63QoIaRdu3aaF/xGjRpF06FeK1asMFJsAAAALLPoaQIAAFAeJEIAADBrSIQAAGDWkAgBAMCsIRECAIBZQyIEAACzhkQIAABmDYkQAADMGhIhAACYNWPNLAMA1VP03RhOqpWNlaWB9RMzcywlgt79+hs1KoAqhEQIYF5K5Srr2k0cXNwMrM+T35CZx43rwGzh1CgAAJg1JEIAADBrSIQAAGDWkAgBAMCsIRECAIBZQyIEAACzhkQIAABmDYkQAADMGhIhAACYNSRCAAAwa0iEAABg1pAIAQDArCERAgCAWUMiBAAAs4ZECAAAZg2JEAAAzBoSIQAAmDUkQgAAMGtIhAAAYNaQCAEAwKwhEQIAgFlDIgQAALOGRAgAAGYNiRAAAMwaEiEAAJg1JEIAADBrSIQAAGDWkAgBAMCsIRECAIBZ4xtv1YWFhSdPnpTJZP369fPw8NCtoFarT506lZKS0rJly2bNmtHCkpKSixcvpqene3t79+rVi883YoQAAADGOiLMzc1t2rTpH3/8cfv27ZCQkPj4eN06o0aNWrBgQVJSUv/+/bdt20YLGzRosGnTpvj4+KVLl7Zo0UIikRgpQgAAAGK8I8Jt27YFBwcfOXKEEGJtbb1q1aqff/5Zs8KDBw9+//331NRUe3v73r17jxgx4uOPPxYIBDdu3PD09CSEKBSKevXqHT9+fOTIkUYKEgAAwFhHhKdPnx4wYAB9PGDAgNOnT2tVOHPmTIcOHezt7QkhnTp1kkql9+7dI4TQLEgIEQgE1tbWDMMYKUIAAABivCPCFy9esNcFPT09s7KylEql5gW/Fy9esDmPy+W6ubm9+L/27jysqSttAPi52dgSCQGEALK7ix2kYnUqRStC+wCOgA6DTu10xPYbq30+v3Fah1HHdqxd5pnOMK3VUZSWPtal9GmLteOKiiAqWpQ+UK2g7AlLErbs957vj6MxTYAm1ngT8/7+ujmck/Pe6zXv3c49HR3m33Do0KHe3t6MjIyRusAYb9u2jaIo8nH69OmpqakPeDWcg8FgMBgMbEdhN4yxoyOnaRphxvajJYwxieruR4YUDVONYdDdXcusHNE0TZrTNI0xsu9ADWODwUCaMPgO29syNGPW9fBtMcNgznBHt/jeXoTt7BpjTN/t2mg02rXB0Y93g5G6xgyDhg/7Xtc0TWNkzxZDiMHIaDSS5gyDSQC2h/3jtR6+7UgbHCNs6rqxsVEmk9keNkIoJCQkKirKriZ2IfshZ9ht/sjhcrk/uaYOfBTFlKLIgsVuZPGRw+EwDGP6eO7cudWrV5eWlpJTxpEolUpTL0NDQ+bf8ChhGMYVVw1j7OjIMcYII2THrxtCCJmHhNFwzTHGCFHD/vBhTJozDIMQtr1r0te9DUIa2h65ZdfDtx1+dRDCCD+Qru8kIjuv05jtBsM3H2lrk87vrbU9/9ak+Y+7tu/fC93d1AzDjNR2xA2O7220qlPHqZbvxUIfGztVDg42R8dFRLxgV6h2YRjGFN4jz5Z876hEKJVK5XI5WZbJZIGBgXw+36JCZWUlWcYYy+Vy0wnixYsXs7OzP/nkk7lz547SBUVR77zzjjsc1Oj1eg8PD7ajsBvG2Gg0OjRyHo+HOBzK5n2AgxmKokwhURSHoijr5tQIB8sUhXg8HmnO5/OHbTsK0jW5LsLhDN/1KG25PO5Pds3BeNhy0jVpTtnZNYeieD/q2o4Nbtk16duqOQchiqIoq1NwRHG43J9e61EiFwgEpDmHw6GQnRucyyFtBQKBvRucQ1F8Pp805/F4ceOjokOCbOz6h7bO61yeQ//jUBSFMXbFXxUHcVQWWbBgwZEjR8jykSNHFixYQJbb2trUajWpcPbsWfJQaHV1NYfDiY+PRwjV1tYuWrRo9+7dCxcudFBsAAAAgImjzghfeuml+Pj4/Px8Pz+/Xbt2nTlzhpTPnj37H//4x5IlS2bMmJGUlJSampqamrpnz54NGzaQw5OFCxcKhcKSkpKSkhKEUE5OztKlSx0UJAAAAOCoRBgcHFxbW3vgwAGdTnf58uXo6GhS/sEHH5AzP4RQaWnpgQMHmpubi4qK5s+fTwo//PBD8yvXU6ZMcVCEAAAAAHLowzJBQUFr1661KMzMzLzXN4+3bNkyiwrZ2dmOCwkAAACw8Og/aQIAAACMAhIhAAAAtwaJEAAAgFuDRAgAAMCtQSIEAADg1iARAgAAcGuQCAEAALg1SIQAAADcGiRCAAAAbg0SIQAAALcGiRAAAIBbg0QIAADArUEiBAAA4NYgEQIAAHBrkAgBAAC4NUiEAAAA3BokQgAAAG4NEiEAAAC3BokQAACAW4NECAAAwK1BIgQAAODWeGwH4FwYhjldfoo2GOxoQ1EzZz0hFosdFhQAAAAHgkT4I1qttqLs8yfC/G1vUt/ZExI2DhIhAAC4KEiElnhc7hNTJ9heX67WOy4YAAAAjgb3CAEAALg1SIQAAADcGiRCAAAAbg0SIQAAALcGiRAAAIBbg0QIAADArUEiBAAA4NZgHCFgWUNDg1qttqtJTEwMvMEAAPCgQCIELDu0d9cEsQeHomys39mr0mUtnzNnjkOjAgC4D0iEgGWYphfETeTzuDbWP32tAWPs0JAAAG4FEiEAADgplUr10c7ttF5nexOuwOO5Vf/j5+fnuKgePZAIAQDASanVaqzsyk6YZHuTL69cHxoagkRoF0iEACGEGhsbtVqt7fU5HE5ERIS3tzdCaGBgoKWlxboOxlij0ZA6FkQiUXh4+H1HC4ALGRgYUDAqEd/WR/SVCsWQt8D0kcflioU+tnfH49p6l2F0DMPcuHGDpmk7uubxYmJieDzXSyuuFzFwhHf+U4KkU2yvr+7pXLtozsyZMxFCtbW1O45fFUrGWtTBCBuNRj6Pb1HOMLSwr/m9La/9zJgBcAlX668PCbBskLGxfptM3oxUDg3JFgqF4tCuDyL9RLY3aVUO5K35v8jISIcF5SiQCAFCCOloFDk32/b6rdX/NT2xgjEWhE6WPp5sXU2v1wsEAotCo16r+LrwfiMFwMXQGAskIcIIWyd34+sQ3at0aEi2wBgLBfzMhMm2Nzlw/pqLPsgGA+pdQHl5uU5nx91yJ6HValtbW9mO4n709/cbDQa2o7AbZhiVkv0f0PswNDjoins4QkihULAdwv1oamr6/vvv2Y7CiTgqEdI0vWPHjry8vFdffVUulw9b58yZMy+88MLKlSvPnz9vKtRoNNu2bcvNzf3b3/42NDTkoPBcy2uvvXbz5k22o7Bbe3t7ZWUl21Hcj9bW1v7+frajsJtWq21sbGQ7ivvR2dnpihmFYZjvGxrYjuJ+lJaW7tu3j+0onIijLo3+9a9/LSsr27hx49GjR+fNm3ft2jWLO6jV1dWZmZl///vfDQZDWlra2bNnH3vsMYTQihUr+vr6XnrppT179uTm5paVlTkoQkfo6upqsPM/hlQqnTDhzjWT9vb2YY+LDQZDW1ubl5eXRTlFUWFhYXw+HyGk0Wg6Ozvt6lokEgUGBtrVBABHcc1Lak6ur6+vt7fXulyhUAwODjY1NVn/SSKRPJDXNvX39/f09NjVxM/Pj62HXR2SCDUazQcffHD06NGZM2dmZWVNmDDh66+/XrRokXmd9957b+3atfn5+QihxsbGwsLCoqKiW7duffXVVx0dHRKJJCUlJSgoqKGhYfJkOy5Ss2vXf3ZdPnNaKBTaWN9oNGo5nM+//JIsv1G4G/tHWlfrEU8sOt3gd1VmUa7r6/7fpSnkAOL8+eq9p655j7F1D2ZoOhCp3tywzsb6AACX89+vvpR9d9nby9OiXHOzjjEYTn6807Jcp/ONnrwi/8Wf3/WJ/37TUlPp4215+D4Snd7gGRq5cvXan9/1fXBIIrxx44Zer3/88ccRQhRFJSUlVVdXWyTCCxcukCyIEEpKSiooKEAIXbp0acqUKRKJBCEkFApnzJhx4cIFF0qENEPHxcbMmGnr27+Uvd1fnCknyxhjHeJGPL3cuhrv+77Ap5Zan721nvvSdGuawQwv4jHpjLk2dq0b6tee3mNjZQCAK2Jo4+yYkInjQizKg3UKvV6/YNY0i/Lbsq5vtQ/m7jimjYmRwVOjxtlYv71bcU7B2o15yhEP+Rw9ejQ/P980tozcJiwuLjav4+XlVVVVFR8fjxCqqqrKyMjo7e0tLCwsKys7fvw4qbN48eLExMQNGzYM2wuHwxGLxdTdd1RKJJKfPzSNpmltZ0uk2NajGISQQq1TeUlEIhFCSCaXjxszxsPT1uYMQzfJ5MGhIQghjHFDh4oWh1pXUyp6x4zx5VqPztEMRAiGxowZgxDq6VV0cAMovuWh34gw7TkgGy+9cyGioV1hFIfZ2hYhpB0K5/X7+voihBQKRRvypzws11qv12s0Q76+Vtc6MBb0t08MkZBP/W23o309KJvfNTqkM3ZwheTqTVdXV5C3l4+PzU94Y3yzvT143J01lbV1xEiDKY7lnXKtRi0QCDhcyw2u06hb+/uDg4MRQj09PRK+gGx8GzW2twWGhHA4HIRQZ3tnbPBYimPrkC+dVt3ad6drhUIxhssRW539Y4ZRazQ+PsOMObvV0eEXNJbcnpB1dESPHWu9diN3rWnt6yNdq1Qqb4wk9lw6a+mUiQL9yQX8zo7OmMAAjtWIGp1Wy+Fw+FYPGOv1uhalknTd19cnMNKBEontXbfK5d5+Yg8PD4SQrEMWFejPtep6JAa9rlmpCg4OQggNDg5SOl2QxN+qFh4aHPQRDrP7dXR380VCcjtD1imL9Jfw+JZrNxKjXtesVAYFByOEdDodRyELEXnY2BYhJBvQGfyCPD09EUKqLlmkgLZ+f6FGrWYwtt5VjDRzW0v5BkkRQgaDgeluDxtj808KQvJBnc53LFlrVZc8UmC0/dWJNM3c0mDf4GF+AH+mrKys1atXj17HIWeEXl5e5ve6tFqt9Rb39PQ01dFqtWTYtXXDYYdjE5s3bza/bTZ27NiwMHt+yl3H7du3w8PDOVa/107OYDDI5XJX/Edpb28PDAy0Hvjh5DDGzc3NrjiKq7u728vLy/Z7Cs7j1q1bUVFRbEdht76+PpqmJfYcVbguW/6BHJIIQ0NDyc1Ysme3tLSQkdfmwsLCWlpannjiCVKB/FySQlMdU/mwNm/e7IjgAQAAuBWHnGTExMRMmzaNPJ7b0dFx8uTJ7OxshFBnZ+dnn31G6mRnZ5eUlGCMGYb55JNPSIXk5OSBgYEzZ84ghGpqalpbWxcuXOiICAEAAADCIfcIEUKnT59esmRJQkJCXV3d8uXL3377bYTQN998k5eXp1QqEUIKhWLevHkeHh5Go5HP5584cYLcZvv444/XrVuXmJh46dKlrVu3rlq1yhHhAQAAAISjEiFCSKVS1dbWhoeHR0dHkxKtVtvb2xsaeud2KE3TNTU1HA4nISHB/AaYXC6vr6+fNGmSVCp1UGwAAAAA4cBECAAAADg/eOm2U1Or1efOnZPJZLGxsXPm2Do8kXU//PBDc3OzecnTTz9t+wCJh29gYKCurk4oFE6fPt28vKmpqampaebMmWSgiLOhabqhoUEmk82fP9/6oeLKykqRSGSxRk5CrVaTt02R0cYIIYVCceXKFfM6v/jFLwICAtiIbkQKhaKyslKlUsXHx0+bdm8QnsFgOHr0qEKhePrpp01XvJxKQ0PDt99+6+XllZSU5O9/ZxyITCa7fPlyV1dXaGjovHnzyBAXN4WBszIajSKRKDk5+fnnn4+KisrMzDQajWwHZZMdO3YsuGvChAkhISEMw7Ad1Ii2bNkiEAj8/PyysrJMhUajkbzwicvlVlVVsRjeSK5du+bj40NShVartfjrkSNH+Hx+Tk4OK7GN7v333xcIBBKJJCkpyVR4+fJl0z4ze/ZshNDVq1dZDNJafX29SCR65plnVqxYERAQ8Oqrr5JyvV7/y1/+cs6cOb/73e8kEkl1dTW7cVrbvHlzeHh4bm5uenq6WCw+d+4cKc/IyEhPT8/Pz58xY8a0adMUCgW7cbIIEqHzYhimsbGRLCsUCl9f3/LyclYjuh+ZmZkbNmxgO4rRdHR0DA0Nbd261TwRmja+WCx2zkQ4ODjY2dlJ3rJtkQj7+vqmTp26atUq50yEMpmsv79/586d5onQ3Pbt26dPn/6Qo/pJKpWqq6uLLF+7dg0hRD4ePHhwypQper0eY/zWW2+lpaWxGeVwbt26ZTqG/tOf/pSammpRwWg0Tp06dc+ePQ89NGfhYmO03QpFUabnjMRiscXbBlyCXC7/5ptvnnvuObYDGY1UKrV+b4P5xndOPj4+5JUr1tavX79mzRrnvEaHEAoKCiKPiI+kqKjI9P5F5+Hr62t6zSHZ8nq9HiF0+PDhRYsWkeuKOTk5x44dI+XOIzIyknt32nqpVGr9M2I0GnU6nbNdiH6YIBG6hl27dolEoqSkJLYDsU9xcfHs2bMnTZrEdiBupLy8/Pr166477qiuru67777Lzc1lO5DRvPHGG2lpaeRQo7293XTMERoayjCMvfPAPDQqlaqwsHDlypWmkt27d6ekpMTGxubl5aWnp7MYG7vgYRkXcOLEiY0bNx45csR6JiYnV1xcPNKrYoEjqNXql19++bPPPnPmR5NGt3v37qysLGc+O9mxY8fhw4crKirIR5qmTU8qkQWj0chacCPTarVLlixJTk5etmyZqTA5OXncuHFXrlz517/+lZWVRaaycUOQCJ1dRUVFXl5eaWlpQkIC27HY59y5cx0dHTk5OWwH4kYOHTqk0Wj++c9/IoSuXLnS29u7fv36d999l+24bKXX6/ft2/fpp5+yHciIiouL33zzzfLyctNZoFQq7erqIstkISTEcrYH1un1+pycnICAgF27dpmXx8bGxsbGpqamNjc379ix48MPP2QrQnZBInRq58+fz8nJ2b9//9y5ts6v5DyKiopyc3NHeW06eOCSkpLIW5wQQiqVisfjudbl9C+++MLLy2vevHlsBzK8gwcPFhQUnDhxIiYmxlSYnJz80UcfkVcfHzt2bNasWc525cZgMCxdutTDw6OkpMR0s9BCT0+P+Uq5GxhQ77wGBwdDQ0OjoqJmzZpFSvLy8p566il2o7LR4OCgVCo9efJkYmIi27H8hMrKyo8//vjbb7/t6elJSUl56qmn8vLyEEKbNm0i04c988wzQUFBW7dudarrdXq9fs2aNf39/fv37//9738vEonee+898wqvv/56XV3doUOH2IpwJFevXt2+fXtDQ8PNmzczMjISEhJMdzRTU1PnzJnjnO/Tr6uri4+PT0pKGj9+PCn54x//OH78+MHBwccee+zJJ5+cOnXqO++8s3fv3oyMDHZDtVBQUPDuu+8uX76cPNEjkUi2bdum0+mSk5NTUlJEIlF1dXVFRcWFCxdccSaNBwLOCJ0Xj8ezuKhlPTev01KpVP/+97+dPwsihAICAhISEkxXnk2zWk6bNi0sLMxUTqa1cx7k3YQIIXL+ZD1pVHp6OhmQ52zEYrH5Bjc9ncswzJIlS5z2kY2AgIDt27ebl5DZdYRC4YULF4qLi1Uq1eHDh8mMOk4lNTU1IiLC9JGELRAItmzZcvHixb6+vtTU1KKiIrE900w+YuCMEAAAgFuD4RMAAADcGiRCAAAAbg0SIQAAALcGiRAAAIBbg0QIAADArUEiBAAA4NYgEQIA0OXLl4uKitiOAgCN7NnKAAAELElEQVR2QCIEgDVVVVXR0dGHDx9+yP3u37//7Nmz5iVlZWUvv/zyQw4DACcBiRAA1qjV6lu3bg0ODj7kfjdu3FhSUvKQOwXAaUEiBMCp9ff3y2SyUd4A1d3dPdK8P3K5XK1W29tjT0+PwWCwtxUArgsSIQBO6uTJkzNmzPD19ZVKpSEhIeYT6GzYsGHSpEkVFRUTJ04cO3asj4/PsmXLtFqtqUJVVdXkyZODg4NFItGvfvWrkpISiUTS2NiIEIqOjm5qaiIlEolk9erVplY1NTVxcXGBgYE+Pj6LFy9++KeqALACEiEAzuj06dNpaWlRUVEVFRW1tbUrVqxYtWqVaaI+jUbT2tq6cuXKgoKCmpqaTZs27du3zzSZXFtb27PPPuvp6Xnq1KkrV65ERkauW7dOqVTSNI0Q2rt3b3Bw8Pz58w8ePHjw4ME//OEPpJXRaFy+fPkrr7xSU1Pz9ttvl5WVudBEhgD8LBgAwJLjx48jhD799FPrPyUmJiYmJhqNRlPJ4sWL4+PjyfIrr7yCEDp58qTpr0lJSXPnziXLf/nLX/h8/u3bt01/XbBgAULo+vXr5GNsbOzKlSvNuyMzH5WWlppKMjMz4+Lifu4aAuAK4IwQAKejVCovXbo0adKk8vLyE3cFBwfX19eTszqEkKenZ3JysqnJlClTWltbyXJdXV1cXJz5zDu2zJBHUVRaWtqwXwjAow3mIwTA6XR1dWGMS0tLy8rKzMu9vb2VSiWZH1gsFnM49w5kPTw89Ho9WZbJZBZTV9oyk6WHh4e3t/ewXwjAow3OCAFwOmPGjEEI/fnPf1ZYIVlwdKGhoZ2dneYlMpnMUbEC4PogEQLgdKRS6YQJEz7//HPThVC7JCQkfPfdd/X19eQjxvjAgQPmFYRCoUajeQCBAvBIgEujALDs/PnzFEWZl6Snp7/11lvZ2dm/+c1vNm3aFBMT09XVVV1dXV9fv2XLlp/8whdffPH9999/9tln33jjDX9//71791qcIE6dOvXUqVNfffVVaGiov79/ZGTkg10jAFwLJEIAWFZYWFhYWGhe0tTUtHjx4v37969fvz4uLo4U+vn5rVmzxpYv9Pf3P3Xq1Nq1a/Pz8318fHJzcwsKCl588UXTZdXXX39dLpf/9re/7e/vf/755/fu3ftg1wgA10Lhkd9YAQBwtGEvfnK5XLKAMb5x40ZfX19AQEB4eDiPd59HruvWrduzZ49Kpbr/QAF4dMEZIQBsMuW8YVEUNXHixPv42vLy8pkzZwqFQoTQsWPHdu7c+etf//o+QwTgUQdnhAA8glJSUioqKiIiIpRKZXd395NPPvnFF1/4+/uzHRcAzggSIQCPIK1We/HixZaWFoZhJk+e/Pjjj1s8jwMAMIFECAAAwK3BOEIAAABuDRIhAAAAtwaJEAAAgFv7f6KtK8V56NTwAAAAAElFTkSuQmCC", + "image/png": "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", "image/svg+xml": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ], "text/html": [ - "" + "" ] }, "metadata": {}, @@ -3555,14 +2597,14 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Natural 'A' frequency: 0.04562383612662942\n" + "Natural 'A' frequency: 0.04726267529665588\n" ] } ], @@ -3572,14 +2614,14 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Natural 'A' frequency: 0.051578034296390206\n" + "Natural 'A' frequency: 0.04435456690259521\n" ] } ],