From 88186cea2257e118cff26815b610bc5263ecceaa Mon Sep 17 00:00:00 2001 From: Gianpaolo Coro Date: Thu, 20 Sep 2012 16:59:38 +0000 Subject: [PATCH] git-svn-id: https://svn.d4science.research-infrastructures.eu/gcube/trunk/data-analysis/EcologicalEngine@58857 82a268e6-3cf1-43bd-a215-b396298e98cf --- cfg/models.properties | 3 +- neuralnetwork_Fis-30189_randomnative | Bin 0 -> 8038 bytes neuralnetwork_Fis-30189_randomsuitable | Bin 0 -> 8524 bytes neuralnetwork_Fis-30189_staticnative | Bin 0 -> 8038 bytes neuralnetwork_Fis-30189_staticsuitable | Bin 0 -> 8524 bytes .../DistributionQualityAnalysis.java | 4 +- .../evaluation/HabitatRepresentativeness.java | 5 +- .../cores/neuralnetworks/Neural_Network.java | 10 +- .../AquamapsNNSuitable.java | 4 +- .../ecoengine/test/ProduceTestMap.java | 2 +- .../latimeria/ExperimentsForLatimeria.java | 303 ++++++++++++++++++ 11 files changed, 315 insertions(+), 16 deletions(-) create mode 100644 neuralnetwork_Fis-30189_randomnative create mode 100644 neuralnetwork_Fis-30189_randomsuitable create mode 100644 neuralnetwork_Fis-30189_staticnative create mode 100644 neuralnetwork_Fis-30189_staticsuitable create mode 100644 src/main/java/org/gcube/dataanalysis/ecoengine/test/experiments/latimeria/ExperimentsForLatimeria.java diff --git a/cfg/models.properties b/cfg/models.properties index 198f710..b7712e2 100644 --- a/cfg/models.properties +++ b/cfg/models.properties @@ -1,3 +1,2 @@ HSPEN=org.gcube.dataanalysis.ecoengine.models.ModelHSPEN -AQUAMAPSNN=org.gcube.dataanalysis.ecoengine.models.ModelAquamapsNN -AQUAMAPSNNNS=org.gcube.dataanalysis.ecoengine.models.ModelAquamapsNNNS \ No newline at end of file +AQUAMAPSNN=org.gcube.dataanalysis.ecoengine.models.ModelAquamapsNN \ No newline at end of file diff --git a/neuralnetwork_Fis-30189_randomnative b/neuralnetwork_Fis-30189_randomnative new file mode 100644 index 0000000000000000000000000000000000000000..757b7e8354fd6ea39ad11a5bd0ed0454e8ac3832 GIT binary patch literal 8038 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 literal 0 HcmV?d00001 diff --git a/neuralnetwork_Fis-30189_randomsuitable b/neuralnetwork_Fis-30189_randomsuitable new file mode 100644 index 0000000000000000000000000000000000000000..2177f8a8209ca3ffcb677963a7ce44e84dc4cacd GIT binary patch literal 8524 zcmbuDdt6P~`^R^eAr-pGk)%RGHzd^A&vPV6lA{YrlkO_1RFb65BvMRba&OWYmry26 zL(*B#(S)YSeB+BLLT*WJF(Ib-o$t)+%luxi{onWewf26W=d#vkU7o#4pK)I#CUA4( z5|-I43tbfwZW9)q6dW8I9J3}dD$yo9G%h@LSyXJe&5F3N@R&rK(71%~M4Q;~RSCf{ zvEfOp;}Vu9+Iar;xYYCSXYTKxiYlk>!VL@#4GoV^3XTm8_lZn!;WSnRr-ZHvjR|+* z`X$CKi-`(e!u4O45cQu{5;uFv5)Wl2wtr<}`_D{lKV@S3cP6%fWn%mPGqL?oCULP& zDe>6$cNUVZlD`@#4Vic4<S>1y|J-$m1(l){Q3JdIeIOIXHee%Te4^Tt#TtJ)~(bR&HAR>lt@oj8>d*@+a0hwSyARI*_(_BRL(q z4H<5h@<$a?l-#}{jx>_N9&=MD^VVX228)=^kv^IbYRbA^xUsv|5`Oo79XQy^!!L4a zO-}L@nlIC)2!{hSPAwXO#&FDB+KfY5a$)?XatvR%1!E?j#&t*2F>bRX4A0_l0E!MqH3%D)6!J7!oc3j9kq_Tg6x_YgHILEJPTJ!j){lv z`^^}_-9X>{huJyZEE?FG#TN&dqKfDQ`{uYkE|MCNMP(5h_PMc1wVUAaQw>b7DPfa- z&8LB*%1K=Q9##*22m^1)(0oEMPBO2;@tztu=D9QKwHg4bzaYrCO0#a~vfAVEU~p#| zs^z9*XoVd`Tnxd*gGN(gh$}SQ>%|2f{^+v1A3CLMfqyBQ+0Cd>n!T)m!rvv}xVKFN zCgUMWRt|PgPGL&Y6il7x19$s7vyc6MMF$Ckswxk1lQdGIYBP&SmcoW|spOPuDE~Cu z11BfevHf8O`Bz8sSyGB6^|ySE>vq`Vi2Mfj)yH_WuZ!R>iEiS$Uu8}@?e+Xp0~@v- znsD_~SMc`gVw=~_hF@v|FzWpwOep4{>*iC|=KdQ@ULa*V(+Z$_TPv;eb;raU32J== zoTvzZf_Y)Yb++^0uaL4S*^%ET@LysLYkqT+V9)zD_FG6DZ^(Q1?mM($pz7Z1BuN=fUulvWmg zC70jP;lKDGBUkMP8kjr}(iW$X%AMP={93$xLCYZIR&Ig}SrdgVNf$r=PR3-qqv0Ff zIvmdVK^dn(3x5ltq1j%fLji1_PZeu?Sqg)1SMdW+w81Ie6dW-yfi>QlNb|Q=$nVPh z#I3ywnA(t!W5x!uNtbkS^cOqWFX8s&QG5%Ie>f@5sZd~Q;9kgh#IfHNSi-Rw4vjsx z&(L06562@M$i*rN$9d+n0*5ZLbqrxYAFIKci<{X8y?T~$UAguw0&ueRbd0q-#&V~& zp=j(%8vX4BN}rI-6z8Puan@y;{icK2ztcrO%?qRtXBGRZ#C*O3FKvzvL$9RxHPc}wMuUbX+#D#?PxJ}80y#GMiYYs z`MIYmZ`5jlpIDTUt*=%v7FOvM(3~ebo zw<&XWbHGIJE2P0IXwjT$tWB!~o(9PHtzJ#c`)CJg>s8^BLn$!x-;r#iuY?tNc2L-N zJ9*FX3LHk7F!D!JRvTr&zOx!2S2?qr=BpmSq3ww<<>*eF{X;BUu}48uf7ZdFJI0gx zvt&$at&mi;4gzsY0SpUiV&n2;{77F3c~9uXF_-Q^nyv=CZMMho=k9Rhlsd^KJ;o)e zSrm~LFW+}b7bcrX`Ij?`(J`?b>H?xMCb5^Ixiscmu!%1n*Mwfb2eNpTdVcLb8R|IK z;>3m9<&`__(0+zBtJ6}zU2zZ1f7S!MTNkVIl`^odN2t3%lT)pPG^&}lR2>RU0!huQ zoYHUR;%t9y*p+q_C;Dum!~{(~V~c{f<|}c?Gkel~Pznjl%Sm-NpzggO8uZ?cxeV#R z;bHESu(y)E(1@2e9Vn-DtCSP$rb>;X=k9!slI0?1n<51xn>%z8x$+6J}b zthz!9k8K6B_ifNw>cgK-%O|Uc+3?%zCV8P*IoQ;R#lPv)qpP|On76oLV2uMP^bbPc zqi(porJ2TRSKzE^<4NO135MObfhl?tXbs#$_-yp{W7|BYL)= zPR;RWoj2-O>2gDwIi{M_cT7XQw|UHQfdn30+yZxAi_UiCaTr^jBBT*Ja`XXQx|m3_ z9zExqKNiEqp&D?$wTi4NBgn|<9z?NtcI!$TtxT`LxlcQxbeRN0?R(g<5(AcIIt@zm zOlh2tnCu!3v-*P)@q>vREgIy-GNlTdU%y+vH7STKn=2)++x=i~nGVJ#)>3k;a!=0g zAjdL0{4(E<6<1f1?O9c3U?fF;?g{b>GeYj)-K<&Do&v%zV0eZRp)`nQ{hp62kEqhj z#sjFoq?vg&#G~PI6F%pFo&1eyKFoPv!)jhwvA55pxMo2b%k;0Iz{hpqkR>9mM|mve z*(R{NBw8~8GSutW(HCM#UW|!dj z=cnbxkJ`Z3>6v`nvoiKaNGqDWy+_`2D&X4@Nl9AiQuk7QdJ#A&>WdFx|Q@_+2)|XL_fooD&fky}F?9L^vdG$1HTmZ#fc+dNr$!KOIMx`(43AUrI4A6fCK{9PH26^S|1r!B3%);?Bvn<%iLAIeLy)HXLRt>6N*vv zwFby5OHgyMtGLvWqhUA8pde~Cq%UoQ%RlB*%-|p>oH`VToK8Di-57_XehhK4&E;V8 z<5?8lrN@kBH$!=+1abnB*oy--6tC7NKKnsI+7pv7Y{P99|CGEe>WnYB#wb(I>Qr^ zucsha5Q9U{2atN!Qksx0!ssYXxyQ0q$c2}(qsCV$r9GMLn{kqLUveRp?SHaA_ccL& zpO4(xtBOXd?q&DRr0^4Gw9(Sv<7xRN4)WF&vc3grIALcEPSJEEqtit&AhwCk7|@Jk z2QDQ2@_RxW5jxyrFFr=H$D<`AQtG; zL>o`?n%^m}XozRE2fFynAB$<->*VUp9*!bnJNfoC3UR+h%6g4Tq2=jT7U(788!pTE zU-C_H&8TZQN~e=-_K&Ba)wfxv&K5TLq4JEq>_hWQt;nk}0S@G;lVM&XbGo5HreI8g zd(6Sb%@SR+qrvZ>6k|o#**D|H!Jh8}DDJ(H;sAs{R=7TM=8zvEuEcA5TTD` zJw`}_#lzh>)Of4>_Q~y_k-N;<53@`8qWUI`=>CQc+?2+yt2JRpNGh&2%0zo(b2L-y zINLj&qcQJ~QLHk?w8JZWjCsA%SBT=M=**krqn%7pna?dHreckU5}b+)^`nLbl#2n z9nyw_e%drIxl%|Y$7|gjikm}FKdYL2^z>MEvL9LfTf`3ip2P-^mGC#uOK9Zl=VZ9w z2)%|WYlA*>G&m+^3|qh${*eObj$6|}Lf%9v~JHe>X77aGdk*!oT@mS$8e|M6Qp zO1rL!(J@&N*Ow`OWl&6Oy&}nWk1ji`l7&WE8uI-UIkd|6SI&=3?Ap~xT>9pMQ_UKV zb@c0n;5A(|=g&;o^37=WvsWFBsS&dWE9=oN(~Yc@>n7(-JgPUkW6E1SoFiMUtdY0l zxUv*nmN}L5^viKoQ8|g?i=m~j1YK@kK$XMs=+G}vesjAusIR+9Bil@Hk#7tO(&A{g zoew3Aum`@WL-|b-PvHx?#78$Ms!y(WLo@3Fac6WPuDiaE<>bULgZ3_Yaele{dT#e$fu>S!9QhMvwzBlo;BdT^jBu7nez(->fD!+mVAR)jGM~1_?BuDIp6l zZ?ZUk1^w>0Ku>fdIi;Pzl}pp1N0vpCI;+_shcH_H6j=589=_LI2CvIwp!Zr0EStNN z`oHs}q4_pwQxya6!lkUWAPZz&jWso6RB^z159IHRM_c80nUAgV%;-LV3tqZVP+A`B)QfuX@}3694X9#PlY(&QxhEJfVK+*D{e|nf#uUCE9{9j!gCB+snGpdgVjd z|Dyz@hpythfkl+8XNto#d?-}Zh@M(iOy_|cd;fMC294-~doF7MH0;>*RtYs03w=V{+w2Ig`CpS`i>*!*+ldTEjvlxow4nSM=&wcnu zp6I?3XlS0ZkR4pPpTg|62M94qie`*r&U8+Qozv{EkgWLjju0cy+yt6%zek8+X1{c? zd)%LbY>h0Q#YTn-G1|243_IfU`R4AQ{o9~_khW#}3EAP~>n>pbgCJ962i%aD_T~%O z(SqMCAYb27h_S=F3UE~JARz`b(l$!Y?)ycE@xEz67YqMpFUSk|L{pN?+$s8ubYq^ zYy~$OwYdnLI3P-VUXINF_g|ILXm-BE|9Zs7y3ul2-&fZ z<{oU}W#KWyi*95$+h52IGrqq;`z!|wF-5fVc+C3gk`R+bt+#}?8)JnSO_|>W=M@Wu zm?A)Z$P5F0;q}0qXEE;;!t=~9^L{!v6iIJL9l;{DAVupaqV28c=%xJJi0(b1zGxa z0~+Z%UWn18jvBbvGD?tfTp-ykausCOtEx~VDO-rK5B;kdi8vvKp$pzAmS#T^Vw9CJ z9WI`95@b3PDkxbdSogq`uS&q&MEDFhoVSI&3lu*4^^NVIK53IsJgC+1hUu3=1exc` zBHAVq+$UIRZ#Tb5W+!CFN)*{Rs=7dk@ehBFhldyIKUKwQpZ@i^DpsL4(zl=9f8M!N VW~d!V6?(7e-d^{~qfiaN{U84Kc?kdj literal 0 HcmV?d00001 diff --git a/neuralnetwork_Fis-30189_staticnative b/neuralnetwork_Fis-30189_staticnative new file mode 100644 index 0000000000000000000000000000000000000000..dc84cc522d1be4352c30ce67bc6864477324d45c GIT binary patch literal 8038 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 templatesOccurrences = new ArrayList(); - templatesOccurrences.add(TableTemplates.OCCURRENCE_AQUAMAPS); - templatesOccurrences.add(TableTemplates.TRAININGSET); - templatesOccurrences.add(TableTemplates.TESTSET); + templatesOccurrences.add(TableTemplates.HCAF); InputTable p1 = new InputTable(templatesOccurrences,"PositiveCasesTable","A Table containing positive cases"); InputTable p2 = new InputTable(templatesOccurrences,"NegativeCasesTable","A Table containing negative cases"); diff --git a/src/main/java/org/gcube/dataanalysis/ecoengine/evaluation/HabitatRepresentativeness.java b/src/main/java/org/gcube/dataanalysis/ecoengine/evaluation/HabitatRepresentativeness.java index 966f6d8..aed7b13 100644 --- a/src/main/java/org/gcube/dataanalysis/ecoengine/evaluation/HabitatRepresentativeness.java +++ b/src/main/java/org/gcube/dataanalysis/ecoengine/evaluation/HabitatRepresentativeness.java @@ -51,8 +51,8 @@ public class HabitatRepresentativeness extends DataAnalysis { InputTable p1 = new InputTable(templates,"ProjectingAreaTable","A Table containing projecting area information"); PrimitiveType p2 = new PrimitiveType(String.class.getName(), null, PrimitiveTypes.STRING, "ProjectingAreaFeaturesOptionalCondition","optional filter for taking area rows","oceanarea>0",true); - InputTable p3 = new InputTable(templatesOccurrences,"PositiveCasesTable","A Table containing positive cases"); - InputTable p4 = new InputTable(templatesOccurrences,"NegativeCasesTable","A Table containing negative cases"); + InputTable p3 = new InputTable(templates,"PositiveCasesTable","A Table containing positive cases"); + InputTable p4 = new InputTable(templates,"NegativeCasesTable","A Table containing negative cases"); // PrimitiveType p5 = new PrimitiveType(String.class.getName(), null, PrimitiveTypes.STRING, "FeaturesColumns","fetures columns names separated by comma","depthmean,depthmax,depthmin, sstanmean,sbtanmean,salinitymean,salinitybmean, primprodmean,iceconann,landdist,oceanarea"); ColumnTypesList p5 = new ColumnTypesList ("PositiveCasesTable","FeaturesColumns", "Features columns", false); @@ -230,6 +230,7 @@ public class HabitatRepresentativeness extends DataAnalysis { AnalysisLogger.getLogger().error("ALERT: AN ERROR OCCURRED DURING HRS CALCULATION : " + e.getLocalizedMessage()); throw e; } finally { + status=100; AnalysisLogger.getLogger().trace("COMPUTATION FINISHED "); } } diff --git a/src/main/java/org/gcube/dataanalysis/ecoengine/models/cores/neuralnetworks/Neural_Network.java b/src/main/java/org/gcube/dataanalysis/ecoengine/models/cores/neuralnetworks/Neural_Network.java index 54f87bf..50e0079 100644 --- a/src/main/java/org/gcube/dataanalysis/ecoengine/models/cores/neuralnetworks/Neural_Network.java +++ b/src/main/java/org/gcube/dataanalysis/ecoengine/models/cores/neuralnetworks/Neural_Network.java @@ -185,7 +185,7 @@ public class Neural_Network implements Serializable { return prop(input, 0); else - System.out.println("Errore:numero di input non valido! "); + System.out.println("Error : number of inputs not valid!"); return null; } @@ -225,7 +225,7 @@ public class Neural_Network implements Serializable { arrayout[i + 1] = trainprop(arrayout[i], i); return arrayout; } else - System.out.println("Errore:numero di input non valido! "); + System.out.println("Error : number of inputs not valid!"); return null; } @@ -308,7 +308,7 @@ public class Neural_Network implements Serializable { public void train(double[][] inputvet, double[][] correctoutputvet) { if (griglia[griglia.length - 1].length != correctoutputvet[0].length) - System.out.println("Errore: il vettore degli output " + "NON ha una lunghezza pari " + "a quella dell'output " + "della rete"); + System.out.println("Error : the vector of outputs has not a lenght equal to the output of the network"); else { double en = 2; int counter = 0; @@ -320,9 +320,7 @@ public class Neural_Network implements Serializable { en += energy(this.propagate(inputvet[i]), correctoutputvet[i]); } - - - System.out.println("errore: " + en); + System.out.println("Learning Score: " + en); counter++; } System.out.println("Scarto Finale: " + en); diff --git a/src/main/java/org/gcube/dataanalysis/ecoengine/spatialdistributions/AquamapsNNSuitable.java b/src/main/java/org/gcube/dataanalysis/ecoengine/spatialdistributions/AquamapsNNSuitable.java index 53ea04c..df3e559 100644 --- a/src/main/java/org/gcube/dataanalysis/ecoengine/spatialdistributions/AquamapsNNSuitable.java +++ b/src/main/java/org/gcube/dataanalysis/ecoengine/spatialdistributions/AquamapsNNSuitable.java @@ -79,10 +79,10 @@ public class AquamapsNNSuitable extends AquamapsSuitable{ } // double [] output = new double[1]; float probability = (float) output[0]; - + /* if (probability>0.1) AnalysisLogger.getLogger().debug(" Probability " + probability); - + */ // System.exit(0); return probability; } diff --git a/src/main/java/org/gcube/dataanalysis/ecoengine/test/ProduceTestMap.java b/src/main/java/org/gcube/dataanalysis/ecoengine/test/ProduceTestMap.java index f492c32..ea88829 100644 --- a/src/main/java/org/gcube/dataanalysis/ecoengine/test/ProduceTestMap.java +++ b/src/main/java/org/gcube/dataanalysis/ecoengine/test/ProduceTestMap.java @@ -44,7 +44,7 @@ public class ProduceTestMap { String finalDistributionKeyColumn = "csquarecode"; // Train -// ModelerT.train(ModelerT.getTrainingConfig(modelName, absenceTable, presenceTable, speciesCode, userName, neuralNetworkLayers, configPath)); + ModelerT.train(ModelerT.getTrainingConfig(modelName, absenceTable, presenceTable, speciesCode, userName, neuralNetworkLayers, configPath)); // Generate GeneratorT.generate(GeneratorT.getGenerationConfig(numberOfResources, generatorName, envelopeTable, preprocessedTable, speciesCode, userName, csquareTable, finalDistributionTable, configPath)); diff --git a/src/main/java/org/gcube/dataanalysis/ecoengine/test/experiments/latimeria/ExperimentsForLatimeria.java b/src/main/java/org/gcube/dataanalysis/ecoengine/test/experiments/latimeria/ExperimentsForLatimeria.java new file mode 100644 index 0000000..f1037c7 --- /dev/null +++ b/src/main/java/org/gcube/dataanalysis/ecoengine/test/experiments/latimeria/ExperimentsForLatimeria.java @@ -0,0 +1,303 @@ +package org.gcube.dataanalysis.ecoengine.test.experiments.latimeria; + +import java.util.HashMap; +import java.util.List; + +import org.gcube.dataanalysis.ecoengine.configuration.AlgorithmConfiguration; +import org.gcube.dataanalysis.ecoengine.datatypes.PrimitiveType; +import org.gcube.dataanalysis.ecoengine.evaluation.DiscrepancyAnalysis; +import org.gcube.dataanalysis.ecoengine.interfaces.Evaluator; +import org.gcube.dataanalysis.ecoengine.interfaces.Generator; +import org.gcube.dataanalysis.ecoengine.interfaces.Modeler; +import org.gcube.dataanalysis.ecoengine.processing.factories.EvaluatorsFactory; +import org.gcube.dataanalysis.ecoengine.processing.factories.GeneratorsFactory; +import org.gcube.dataanalysis.ecoengine.processing.factories.ModelersFactory; +import org.gcube.dataanalysis.ecoengine.test.regression.Regressor; + +public class ExperimentsForLatimeria { + + + static String absenceRandom = "absence_data_latimeria_random"; + static String absenceStatic = "absence_data_latimeria"; + static String aquamapsSuitableTable = "hspec_suitable_latimeria_chalumnae"; + static String aquamapsNativeTable = "hspec_native_latimeria_chalumnae"; + + private static AlgorithmConfiguration configAquamapsSuitable() { + + AlgorithmConfiguration config = Regressor.getConfig(); + config.setNumberOfResources(5); + config.setModel("AQUAMAPS_SUITABLE"); + config.setParam("DistributionTable",aquamapsSuitableTable ); + config.setParam("CsquarecodesTable", "hcaf_d"); + config.setParam("EnvelopeTable", "hspen_latimeria"); + config.setParam("OccurrencePointsTable", "occurrencecells"); + config.setParam("CreateTable", "true"); + + return config; + } + + private static AlgorithmConfiguration configAquamapsNative() { + + AlgorithmConfiguration config = Regressor.getConfig(); + config.setNumberOfResources(5); + config.setModel("AQUAMAPS_NATIVE"); + config.setParam("DistributionTable", aquamapsNativeTable); + config.setParam("CsquarecodesTable", "hcaf_d"); + config.setParam("EnvelopeTable", "hspen_latimeria"); + config.setParam("OccurrencePointsTable", "occurrencecells"); + config.setParam("CreateTable", "true"); + + return config; + } + + private static AlgorithmConfiguration configAquamapsNNSuitable(String tableName,String username) { + + AlgorithmConfiguration config = Regressor.getConfig(); + config.setNumberOfResources(5); + config.setModel("AQUAMAPS_SUITABLE_NEURALNETWORK"); + config.setParam("DistributionTable", tableName); + config.setParam("CsquarecodesTable", "hcaf_d"); + config.setParam("EnvelopeTable", "hspen_latimeria"); + config.setParam("OccurrencePointsTable", "occurrencecells"); + config.setParam("CreateTable", "true"); + config.setParam("SpeciesName", "Fis-30189"); + config.setParam("UserName", username); + + return config; + } + + private static AlgorithmConfiguration configAquamapsNNNative(String tableName,String username) { + + AlgorithmConfiguration config = Regressor.getConfig(); + config.setNumberOfResources(5); + config.setModel("AQUAMAPS_NATIVE_NEURALNETWORK"); + config.setParam("DistributionTable", tableName); + config.setParam("CsquarecodesTable", "hcaf_d"); + config.setParam("EnvelopeTable", "hspen_latimeria"); + config.setParam("OccurrencePointsTable", "occurrencecells"); + config.setParam("CreateTable", "true"); + config.setParam("SpeciesName", "Fis-30189"); + config.setParam("UserName", username); + + return config; + } + + public static AlgorithmConfiguration configSuitableNeuralNetworkTraining(String absenceTable,String username) { + + AlgorithmConfiguration config = Regressor.getConfig(); + config.setNumberOfResources(5); + + config.setModel("AQUAMAPSNN"); + config.setParam("AbsenceDataTable", absenceTable); + config.setParam("PresenceDataTable", "presence_data_latimeria"); + config.setParam("SpeciesName", "Fis-30189"); + config.setParam("UserName",username); + config.setParam("LayersNeurons", "100"+AlgorithmConfiguration.getListSeparator()+"2"); + + return config; + } + + public static AlgorithmConfiguration configNativeNeuralNetworkTraining(String absenceTable,String username) { + + AlgorithmConfiguration config = Regressor.getConfig(); + config.setNumberOfResources(5); + + config.setModel("AQUAMAPSNN"); + config.setParam("AbsenceDataTable", absenceTable); + config.setParam("PresenceDataTable", "presence_data_latimeria"); + config.setParam("SpeciesName", "Fis-30189"); + config.setParam("UserName", username); + config.setParam("LayersNeurons", "100"); + + return config; + } + + + public static AlgorithmConfiguration configQualityAnalysis(String table,String absenceTable){ + + AlgorithmConfiguration config = Regressor.getConfig(); + config.setNumberOfResources(1); + config.setAgent("QUALITY_ANALYSIS"); + config.setParam("PositiveCasesTable","presence_data_latimeria"); + config.setParam("NegativeCasesTable",absenceTable); + config.setParam("PositiveCasesTableKeyColumn","csquarecode"); + config.setParam("NegativeCasesTableKeyColumn","csquarecode"); + config.setParam("DistributionTable",table); + config.setParam("DistributionTableKeyColumn","csquarecode"); + config.setParam("DistributionTableProbabilityColumn","probability"); + config.setParam("PositiveThreshold","0.8"); + config.setParam("NegativeThreshold","0.3"); + + return config; + } + + public static AlgorithmConfiguration configDiscrepancyAnalysis(String table1,String table2){ + + AlgorithmConfiguration config = Regressor.getConfig(); + config.setNumberOfResources(1); + config.setAgent("DISCREPANCY_ANALYSIS"); + config.setParam("FirstTable",table1); + config.setParam("SecondTable",table2); + config.setParam("FirstTableCsquareColumn","csquarecode"); + config.setParam("SecondTableCsquareColumn","csquarecode"); + config.setParam("FirstTableProbabilityColumn","probability"); + config.setParam("SecondTableProbabilityColumn","probability"); + config.setParam("ComparisonThreshold","0.1"); + + return config; + } + + public static AlgorithmConfiguration configHRSAnalysis(String projectiontable,String absenceTable){ + + AlgorithmConfiguration config = Regressor.getConfig(); + config.setNumberOfResources(1); + config.setAgent("HRS"); + config.setParam("ProjectingAreaTable", projectiontable); + config.setParam("ProjectingAreaFeaturesOptionalCondition", "where oceanarea>0"); + config.setParam("FeaturesColumns", "depthmean"+AlgorithmConfiguration.getListSeparator()+"depthmax"+AlgorithmConfiguration.getListSeparator()+"depthmin"+AlgorithmConfiguration.getListSeparator()+" sstanmean"+AlgorithmConfiguration.getListSeparator()+"sbtanmean"+AlgorithmConfiguration.getListSeparator()+"salinitymean"+AlgorithmConfiguration.getListSeparator()+"salinitybmean"+AlgorithmConfiguration.getListSeparator()+" primprodmean"+AlgorithmConfiguration.getListSeparator()+"iceconann"+AlgorithmConfiguration.getListSeparator()+"landdist"+AlgorithmConfiguration.getListSeparator()+"oceanarea"); + config.setParam("PositiveCasesTable", "presence_data_latimeria"); + config.setParam("NegativeCasesTable", absenceTable); + + return config; + } + + static String staticsuitable = "staticsuitable"; + static String randomsuitable = "randomsuitable"; + static String staticnative = "staticnative"; + static String randomnative = "randomnative"; + + public static void trainNeuralNetworks() throws Exception{ + + List modelers = null; + + modelers = ModelersFactory.getModelers(configSuitableNeuralNetworkTraining(absenceStatic,staticsuitable)); + modelers.get(0).init(); + Regressor.process(modelers.get(0)); + modelers = null; + + modelers = ModelersFactory.getModelers(configSuitableNeuralNetworkTraining(absenceRandom,randomsuitable)); + modelers.get(0).init(); + Regressor.process(modelers.get(0)); + modelers = null; + + modelers = ModelersFactory.getModelers(configNativeNeuralNetworkTraining(absenceStatic,staticnative)); + modelers.get(0).init(); + Regressor.process(modelers.get(0)); + modelers = null; + + modelers = ModelersFactory.getModelers(configNativeNeuralNetworkTraining(absenceRandom,randomnative)); + modelers.get(0).init(); + Regressor.process(modelers.get(0)); + modelers = null; + + } + + static String nntablesuitable = "hspec_suitable_neural_latimeria_chalumnae"; + static String nntablesuitableRandom = "hspec_suitable_neural_latimeria_chalumnae_random"; + static String nntablenative = "hspec_native_neural_latimeria_chalumnae"; + static String nntablenativeRandom = "hspec_native_neural_latimeria_chalumnae_random"; + public static void generateAquamapsNativeSuitableNeuralNetwokrs() throws Exception{ + List generators = null; + + generators = GeneratorsFactory.getGenerators(configAquamapsNNSuitable(nntablesuitable,staticsuitable)); + generators.get(0).init(); + Regressor.process(generators.get(0)); + generators = null; + + generators = GeneratorsFactory.getGenerators(configAquamapsNNSuitable(nntablesuitableRandom,randomsuitable)); + generators.get(0).init(); + Regressor.process(generators.get(0)); + generators = null; + + generators = GeneratorsFactory.getGenerators(configAquamapsNNNative(nntablenative,staticnative)); + generators.get(0).init(); + Regressor.process(generators.get(0)); + generators = null; + + generators = GeneratorsFactory.getGenerators(configAquamapsNNNative(nntablenativeRandom,randomnative)); + generators.get(0).init(); + Regressor.process(generators.get(0)); + generators = null; + } + + public static void generateAquamapsNativeSuitable() throws Exception{ + List generators = null; + + generators = GeneratorsFactory.getGenerators(configAquamapsSuitable()); + generators.get(0).init(); + Regressor.process(generators.get(0)); + generators = null; + + + generators = GeneratorsFactory.getGenerators(configAquamapsNative()); + generators.get(0).init(); + Regressor.process(generators.get(0)); + generators = null; + + } + + public static void calcdiscrepancy(String table1,String table2) throws Exception{ + List evaluators = null; + evaluators = EvaluatorsFactory.getEvaluators(configDiscrepancyAnalysis(table1, table2)); + evaluators.get(0).init(); + Regressor.process(evaluators.get(0)); + PrimitiveType output = (PrimitiveType) evaluators.get(0).getOutput(); + HashMap out = (HashMap)output.getContent(); + DiscrepancyAnalysis.visualizeResults(out); + evaluators = null; + } + + public static void calcquality(String table1,String absenceTable) throws Exception{ + List evaluators = null; + evaluators = EvaluatorsFactory.getEvaluators(configQualityAnalysis(table1, absenceTable)); + evaluators.get(0).init(); + Regressor.process(evaluators.get(0)); + PrimitiveType output = (PrimitiveType) evaluators.get(0).getOutput(); + HashMap out = (HashMap)output.getContent(); + DiscrepancyAnalysis.visualizeResults(out); + evaluators = null; + } + + static String hcaf= "hcaf_d"; + public static void calcHRS(String hcaf,String absenceTable) throws Exception{ + List evaluators = null; + evaluators = EvaluatorsFactory.getEvaluators(configHRSAnalysis(hcaf, absenceTable)); + evaluators.get(0).init(); + Regressor.process(evaluators.get(0)); + PrimitiveType output = (PrimitiveType) evaluators.get(0).getOutput(); + HashMap out = (HashMap)output.getContent(); + DiscrepancyAnalysis.visualizeResults(out); + evaluators = null; + } + + public static void main(String[] args) throws Exception{ + +// generateAquamapsNativeSuitable(); +// trainNeuralNetworks(); +// generateAquamapsNativeSuitableNeuralNetwokrs(); + + /* + calcdiscrepancy(aquamapsSuitableTable, nntablesuitable); + calcdiscrepancy(aquamapsSuitableTable, nntablesuitableRandom); + calcdiscrepancy(aquamapsNativeTable, nntablenative); + calcdiscrepancy(aquamapsNativeTable, nntablenativeRandom); + */ + + /* + calcquality(aquamapsSuitableTable, absenceStatic); + calcquality(aquamapsSuitableTable, absenceRandom); + calcquality(nntablesuitable, absenceStatic); + calcquality(nntablesuitable, absenceRandom); + calcquality(nntablesuitableRandom, absenceStatic); + calcquality(nntablesuitableRandom, absenceRandom); + calcquality(nntablenative, absenceStatic); + calcquality(nntablenative, absenceRandom); + calcquality(nntablenativeRandom, absenceStatic); + calcquality(nntablenativeRandom, absenceRandom); + */ + + calcHRS(hcaf,absenceStatic); + calcHRS(hcaf,absenceRandom); + + } +}