Shift_JIS
"""""","""Lift""","""Lift"""
"""""","""Leverage""","""Leverage"""
"""""","""Conviction""","""Conviction"""
"""""","""Finds association rules.""","""փ[̐"""
"""""","""Removed : ""","""菜ꂽ: """
"""""",""" columns with all missing """,""" l̂鑮"""
"""""","""values.""","""l"""
"""""","""Setting upper bound min support to : ""","""ŏxx̏ݒF """
"""""","""\tThe minimum confidence of a rule. (default = ""","""\t[̍ŏmMx (ftHg="""
"""""","""\tThe delta by which the minimum support is decreased in\n""","""\tdeltaɂčŏxx\n"""
"""""","""\teach iteration. (default = ""","""\tꂼ̌JԂ (ftHg="""
"""""","""\tThe lower bound for the minimum support. (default = ""","""\tŏxx̉(ftHg="""
"""""","""\tIf used, rules are tested for significance at\n""","""\tgp΁C[W͏^̗LӐɂ茟肳܂D\n"""
"""""","""\tthe given level. Slower. (default = no significance testing)""","""\tCxȂ܂D(ftHg=Ȃ)"""
"""""","""\tIf set the itemsets found are also output. (default = no)""","""\tZbgƃACeWo͂܂ (ftHg=)"""
"""""","""\tThe metric type by which to rank rules. (default = ""","""\t[𐮗񂷂K (ftHg="""
"""""","""confidence)""","""mMx)"""
"""""","""-T <0=confidence | 1=lift | ""","""-T <0=mMx| 1=Lift |"""
"""""","""2=leverage | 3=Conviction>""","""2=leverage | 3=Conviction>"""
"""""","""-C <minimum metric score of a rule>""","""-C <[̍ŏK>"""
"""""","""-D <delta for minimum support>""","""-D <ŏxx̔ړl>"""
"""""","""\tUpper bound for minimum support. ""","""\tŏxx̏"""
"""""","""(default = 1.0)""","""(ftHg = 1.0)"""
"""""","""-U <upper bound for minimum support>""","""-U <ŏxx̏>"""
"""""","""-M <lower bound for minimum support>""","""-M <ŏxx̉>"""
"""""","""\tRemove columns that contain ""","""\tl܂ޑ̏"""
"""""","""all missing values (default = no)""","""(ftHg=Ȃ)"""
"""""","""\tReport progress iteratively. (default ""","""\tJԂ̕ (ftHg"""
"""""","""\nApriori\n=======\n\n""","""\nAvI\n=======\n\n"""
"""""","""Minimum support: ""","""ŏxx: """
"""""","""Minimum metric <""","""ŏK<"""
"""""","""confidence>: ""","""mMx>: """
"""""","""lift>: """,""""""
"""""","""leverage>: """,""""""
"""""","""conviction>: """,""""""
"""""","""Significance level: ""","""LӐ: """
"""""","""Number of cycles performed: ""","""JԂ: """
"""""","""\nGenerated sets of large itemsets:\n""","""\ꂽ[WACeW̏W:\n"""
"""""","""\nSize of set of large itemsets L(""","""\n[WACeW̏W̑傫 L("""
"""""","""\nLarge Itemsets L(""","""\n[WACeW L("""
"""""","""    conf:(""","""   mMx:("""
"""""",""" lift:(""",""""""
"""""",""" lev:(""",""""""
"""""",""" conv:(""",""""""
"""""","""Remove columns with all missing values.""","""SČl̑"""
"""""","""Upper bound for minimum support. Start iteratively decreasing ""","""ŏ̃T|[ĝ߂̏B JԂɌn߂ĂB"""
"""""","""minimum support from this value.""","""̒l̍ŏ̃T|[gB"""
"""""","""Lower bound for minimum support.""","""ŏ̃T|[ĝ߂̃oEh낵ĂB"""
"""""","""Set the type of metric by which to rank rules. Confidence is ""","""Kit郁[g@̃^Cvݒ肵ĂB Mp͂łB"""
"""""","""the proportion of the examples covered by the premise that are also ""","""OłJo[ꂽ̊"""
"""""","""covered by the consequence. Lift is confidence divided by the ""","""ʂŁA܂B tg͕ꂽMpłB"""
"""""","""proportion of all examples that are covered by the consequence. This ""","""ʂŃJo[Ă邷ׂĂ̗̊B """
"""""","""is a measure of the importance of the association that is independent ""","""ƗĂ鋦̏dv肪܂B"""
"""""","""of support. Leverage is the proportion of additional examples covered ""","""T|[gɂāB Ă̍p̓Jo[ꂽǉ̊łB"""
"""""","""by both the premise and consequence above those expected if the ""","""̏̑Oƌʂ\z"""
"""""","""premise and consequence were independent of each other. The total ""","""Oƌʂ݂͌ƗĂ܂B v"""
"""""","""number of examples that this represents is presented in brackets ""","""ꂪ\̐͊ʂɎ܂B"""
"""""","""following the leverage. Conviction is ""","""Ă̍pɑ܂B MO͂łB"""
"""""","""another measure of departure from independence and furthermore takes into ""","""ʂ̂̂́AƗ̏o𑪒肵āȀAAĂ܂B"""
"""""","""account implicaton. Conviction is given ""","""implicatonĂB MO^܂B"""
"""""","""by P(premise)P(!consequence) / P(premise, !consequence).""","""P(肷)P()/P(OA)ŁB"""
"""""","""Minimum metric score. Consider only rules with scores higher than ""","""ŏ̃[g@̃XRAB XRAA荂ԂŋKlĂB"""
"""""","""this value.""","""̒lB"""
"""""","""Iteratively decrease support by this factor. Reduces support ""","""̗vfŃT|[gIterativelyɌĂB T|[g}܂B"""
"""""","""until min support is reached or required number of rules has been ""","""܂ŁAT|[g͒BĂ邩KvȐ̋KƂƂłB"""
"""""","""Significance level. Significance test (confidence metric only).""","""LӐB dvxeXgA(Mp[g@AP)"""
"""""","""\n\nApriori options:\n\n""","""n~\nAprioriIvV: \n\n"""
"""""","""premis count: ""","""premis͐܂: """
"""""",""" consequence count """,""" ʃJEg"""
"""""",""" total trans """,""" A-"""
"""""","""ItemSet: Unknown metric type!""","""ItemSet: m̃[g@̃^Cv!"""
"""""","""No model associator set""","""ǂȃfassociatorZbg܂łB"""
"""""","""For class association rule mining a class attribute has to be specified.""","""NXǨ@ƂāANX͎w肳Ȃ΂Ȃ܂B"""
"""""","""Finds association rules sorted by predictive accuracy.""","""\̐xɂĕނꂽK܂B"""
"""""","""\tThe required number of rules. (default = ""","""\tThe͋K̐KvƂ܂B (ftHg="""
"""""","""-N <required number of rules output>""","""-NKvȐ̋Ko͂<>"""
"""""","""\nNo large itemsets and rules found!\n""","""\nNȏ傫itemsetsƋK\n܂B"""
"""""","""\nPredictiveApriori\n===================\n\n""",""""""
"""""","""\nBest rules found:\n\n""","""nBestK\: \n\n"""
"""""","""    acc:(""",""" acc:A("""
"""""","""Number of rules to find.""","""K̐B"""
"""""","""\n\nPredictiveApriori options:\n\n""","""n~\nPredictiveAprioriIvV: \n\n"""
"""""","""-t <training file>\n""","""-t<g[jOt@C>\n"""
"""""","""\tThe name of the training file.\n""","""\tThe̓g[jOɂăt@C\nƖ܂B"""
"""""","""Dataset has no attributes!""","""f[^Zbgɂ́AS܂!"""
"""""","""Dataset has to many attributes for prior estimation!""","""f[^Zbg͐̌ς̂߂̑̑ɂ܂!"""
"""""","""Dataset has no instances!""","""f[^Zbgɂ́AႪS܂!"""
"""""","""Prior initialisation impossible""","""s\Ȑ̏"""
"""""","""RuleItem denominator: ""","""RuleItem: """
"""""","""RuleItem numerator: ""","""RuleItemq: """
"""""","""not ""","""not"""
"""""","""TRUE""","""{"""
"""""","""FALSE""",""""""
"""""","""No identifier found in individuals dataset.""","""ʎq͌lf[^ZbgŌ܂łB"""
"""""","""No identifier found in parts dataset.""","""ʎq͕if[^ZbgŌ܂łB"""
"""""","""Body""","""{fB["""
"""""","""Head""","""wbh"""
"""""","""Both""",""""""
"""""","""Matches all""","""ׂĂ킹܂B"""
"""""","""Matches none""","""Ȃɂ킹܂B"""
"""""","""Significant""","""dv"""
"""""","""stdout""",""""""
"""""","""Window""",""""""
"""""","""Finds rules according to confirmation measure.""","""mFɏ]K肷̂킩܂B"""
"""""","""\tSet maximum number of confirmation  ""","""\tSető吔̊mF"""
"""""","""values in the result. (default: 10)""","""ʂɂlB (ftHg: 10)"""
"""""","""-K <number of values in result>""","""-K<ʂɂAl̐>"""
"""""","""\tSet frequency threshold for pruning. ""","""荞݂̂߂\tSetpx~B"""
"""""","""-F <frequency threshold>""","""-F<px~>"""
"""""","""\tSet confirmation threshold. ""","""\tSetmF~B"""
"""""","""-C <confirmation threshold>""","""-C<mF~>"""
"""""","""\tSet noise threshold : maximum frequency ""","""\tSetG~: ő̕px"""
"""""","""of counter-examples.\n\t0 gives only ""","""t0Bɗ^\n\ɂ"""
"""""","""satisfied rules. (default: 1)""","""ĂKB (ftHg: 1)"""
"""""","""-N <noise threshold>""","""-N<G~>"""
"""""","""\tAllow attributes to be repeated in a ""","""tAllowaŌJԂ邽߂Ɍʂƍl\"""
"""""","""same rule.""","""KB"""
"""""","""\tSet maximum number of literals in a ""","""a\tSető吔Ɋւ뎚A"""
"""""","""rule. (default: 4)""","""ĂB (ftHg: 4)"""
"""""","""-L <number of literals>""","""-L<뎚A̐>"""
"""""","""\tSet the negations in the rule. ""","""\͋KŔےtSet܂B"""
"""""","""-G <0=no negation | ""","""-G<0=ے肪܂|"""
"""""","""1=body | ""","""1={fB[| """
"""""","""2=head | ""","""2=wbh| """
"""""","""3=body and head>""","""3={fB[Ɠ>"""
"""""","""\tConsider only classification rules.""","""ނ\tConsiderB"""
"""""","""\tSet index of class attribute. ""","""tSetNX\B"""
"""""","""(default: last).""","""(ftHgƂĂ: Ō)łB."""
"""""","""\tConsider only horn clauses.""","""\tConsider͐߂pœ˂łB"""
"""""","""\tKeep equivalent rules.""","""\tKeep͓܂B"""
"""""","""\tKeep same clauses.""","""\tKeep̓߁B"""
"""""","""\tKeep subsumed rules.""","""\tKeep͋K܂B"""
"""""","""\tSet the way to handle missing values. ""","""\͌l@tSet܂B"""
"""""","""-I <0=always match | ""","""-<0=}b`|"""
"""""","""1=never match | ""","""1=}b`łȂ| """
"""""","""2=significant>""","""2=dvłA>"""
"""""","""\tUse ROC analysis. ""","""\tUse ROĆB"""
"""""","""\tSet the file containing the parts of ""","""\͕i܂ރt@CtSet܂B"""
"""""","""the individual for individual-based ""","""XłAX̃x[X"""
"""""","""learning.""","""wKB"""
"""""","""-p <name of file>""","""-p<t@C̖O>"""
"""""","""\tSet output of current values. ""","""tSeto͂sl\B"""
"""""","""(default: 0)""","""(ftHg: 0)"""
"""""","""-P <0=no output | ""","""-P<0=m[Ƃ̂͏o͂܂|"""
"""""","""1=on stdout | ""","""stdout̏1=| """
"""""","""2=in separate window>""","""ʁX̑2=>"""
"""""","""Invalid value for -K option: ""","""-KIvV̂߂̖̒l: """
"""""","""Number of confirmation values has to be ""","""A肪݂Ȃ΂ȂȂmFɂ́AȂƂƁB"""
"""""","""Invalid value for -F option: ""","""-FIvV̂߂̖̒l: """
"""""","""Frequency threshold has to be between ""","""~Ȃ΂ȂȂpx"""
"""""","""Invalid value for -C option: ""","""-CIvV̂߂̖̒l: """
"""""","""Confirmation threshold has to be between ""","""~Ȃ΂ȂȂmF"""
"""""","""Specifying both a number of confirmation ""","""̑̊mFw肵܂B"""
"""""","""values and a confirmation threshold ""","""lƊmF~"""
"""""","""doesn't make sense!""","""ł܂!"""
"""""","""Invalid value for -N option: ""","""-NIvV̂߂̖̒l: """
"""""","""Noise threshold has to be between ""","""~Ȃ΂ȂȂG"""
"""""","""zero and one!""","""[1!"""
"""""","""Invalid value for -L option: ""","""-LIvV̂߂̖̒l: """
"""""","""Number of literals has to be ""","""뎚A̐͂Ȃ΂Ȃ܂B"""
"""""","""greater than one!""","""1ȏ!"""
"""""","""Invalid value for -G option: ""","""-GIvV̂߂̖̒l: """
"""""","""Value for -G option has to be ""","""-GIvV̂߂̒l͂Ȃ΂Ȃ܂B"""
"""""","""between zero and three!""","""[?3!"""
"""""","""Invalid value for -c option: ""","""-cIvV̂߂̖̒l: """
"""""","""Considering horn clauses doesn't make sense ""","""p̐߂l̂͗ł܂B"""
"""""","""if negation allowed!""","""ꂽے!"""
"""""","""Invalid value for -I option: ""","""-IIvV̂߂̖̒l: """
"""""","""Value for -I option has to be ""","""-IIvV̂߂̒l͂Ȃ΂Ȃ܂B"""
"""""","""Invalid value for -P option: ""","""-PIvV̂߂̖̒l: """
"""""","""Value for -P option has to be ""","""-PIvV̂߂̒l͂Ȃ΂Ȃ܂B"""
"""""","""between zero and two!""","""[?2!"""
"""""","""Number of best confirmation values to find.""","""钆ōłǂmFl̐B"""
"""""","""Minimum proportion of instances satisfying head and body of rules""","""K̃wbhƃ{fB[𖞂̍ŏ̕"""
"""""","""Minimum confirmation of the rules.""","""K̍ŏ̊mFB"""
"""""","""Maximum proportion of counter-instances of rules. ""","""K̃JE^̍ő̕B"""
"""""","""If set to 0, only satisfied rules will be given.""","""0ɐݒ肷ƁAĂK^ł傤B"""
"""""","""Repeated attributes allowed.""","""eꂽJԂ܂B"""
"""""","""Maximum number of literals in a rule.""","""Kɂő吔Ɋւ뎚AB"""
"""""","""Set the type of negation allowed in the rule. ""","""Kŋꂽے̃^Cvݒ肵ĂB"""
"""""","""Negation can be allowed in the body, in the head, in both ""","""{fB[AwbhAŔےƂł܂B"""
"""""","""or in none.""","""܂́AȂɂŁB"""
"""""","""Find only rules with the class in the head.""","""NXƋɃwbhŋKĂB"""
"""""","""Index of the class attribute. If set to 0, the class will be the last attribute.""","""NX̃CfbNXB 0ɐݒ肳ƁANX͍Ō̑ɂȂł傤B"""
"""""","""Find rules with a single conclusion literal only.""","""̌_ʂł̋KĂB"""
"""""","""Keep equivalent rules. ""","""ȋKĂB"""
"""""","""A rule r2 is equivalent to a rule r1 if the body of r2 is the ""","""r2̃{fB[łȂAKr2͋Kr1ɓłB"""
"""""","""negation of the head of r1, and the head of r2 is the ""","""r1̃wbh̔ےAr2̃wbh͂łB"""
"""""","""negation of the body of r1.""","""r1̃{fB[̔ےB"""
"""""","""Keep rules corresponding to the same clauses. ""","""߂ɑΉĂ̂ɋKĂB"""
"""""","""If set to false, only the rule with the best confirmation ""","""łǂmFŋKɃZbgĂȂ"""
"""""","""value and rules with a lower number of counter-instances ""","""̐̃JE^ႪlƋK"""
"""""","""will be kept.""","""ۂł傤B"""
"""""","""Keep subsumed rules. ""","""ꂽKĂB"""
"""""","""If set to false, subsumed rules will only be kept if they ""","""āAꂽKւ̃ZbgłꍇɂێȂ"""
"""""","""have a better confirmation or a lower number of counter-instances.""","""ǂmF̐̃JE^ĂB"""
"""""","""Set the way to handle missing values. ""","""l@ݒ肵ĂB"""
"""""","""Missing values can be set to match any value, or never match values ""","""ǂȒl킹ȂA܂͌llɌčȂ悤ɐݒ肷邱Ƃł
"""""",B"""
"""""","""or to be significant and possibly appear in rules.""","""܂́AƂɂƏdvł悤ɋKŌ܂B"""
"""""","""Return TP-rate and FP-rate for each rule found.""","""TP-[gƌꂽꂼFP-[gKԂĂB"""
"""""","""Set file containing the parts of the individual ""","""l̕܂ރt@Cݒ肵ĂB"""
"""""","""for individual-based learning.""","""X̃x[X̊wK̂߂ɁB"""
"""""","""Give visual feedback during the search. ""","""̊ԁArWAEtB[hobN^ĂB"""
"""""","""The current best and worst values can be output either to stdout or to a separate window.""","""݂̍łǂčłlstdoutA܂́AʁX̑ւ̏o͂ł邩܂B"""
"""""","""Can't handle numeric attributes!""","""lƂł܂!"""
"""""","""Class index has to be between zero ""","""[̊Ԃɂ́ANXCfbNXȂ΂Ȃ܂B"""
"""""","""and the number of attributes!""","""āA̐!"""
"""""","""Stop search""","""~߂ĂB"""
"""""","""Tertius status""","""Tertius"""
"""""","""Best and worst current values:""","""łǂčłsl:"""
"""""","""0.000000 0.000000 - 0.000000 0.000000""",""""""
"""""","""\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b""",""""""
"""""","""\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b""",""""""
"""""","""mm 'min' ss 's' SSS 'ms'""","""'mm''ss'SSS'ms'"""
"""""","""\nTertius\n=======\n\n""",""""""
"""""","""\nNumber of hypotheses considered: ""","""\nNumber͍l܂: """
"""""","""\nNumber of hypotheses explored: ""","""\nNumber͒T܂: """
"""""","""\nTime: """,""""""
"""""","""\n\nNot enough memory to continue the search""","""𑱂邱Ƃł邭炢n~\nNotL"""
"""""","""\n\nSearch interrupted""","""\n\nSearch͒f܂B"""
"""""","""\n\nTertius options:\n\n""","""n~\nTertiusIvV: \n\n"""
"""""","""\tSet training file.\n""","""\tSetg[jOt@C\n"""
"""""","""No training file given!""","""^Ȃg[jOt@C!S"""
"""""","""No model evaluator set""","""ǂȃf]҂Zbg܂łB"""
"""""","""weka.attributeSelection.BestFirst -N 10""","""weka.attributeSelection.BestFirst-N10"""
"""""","""Ranking has not been performed""","""LO͎sĂ܂B"""
"""""","""No feature selection has been performed yet!""","""I͑S܂sĂ܂!"""
"""""","""No training file given.""","""t@C̓g[jO^܂łB"""
"""""","""Attribute selection has not been performed yet!""","""I͂܂sĂ܂!"""
"""""","""\n\n=== Attribute selection ""","""\n\n=== I"""
"""""",""" fold cross-validation """,""" Ă鍇@܂d˂ĂB"""
"""""","""(stratified), seed: ""","""(w)łB, q: """
"""""","""seed: ""","""q: """
"""""","""average merit      average rank  attribute\n""","""ςςN\n"""
"""""","""number of folds (%)  attribute\n""","""܂(%)̑\n̐"""
"""""","""Can't cross validate an attribute transformer.""","""\͑ψLɂ邱Ƃł܂?"""
"""""",""" must use a search method other than Ranker""",""" K{RankerȊǑ\bhgp܂B"""
"""""","""AttributeEvaluators must use a Ranker search ""","""AttributeEvaluatorsRankergpȂ΂Ȃ܂B"""
"""""","""method. Switching to Ranker...""","""\bhB 胉Nɐ؂ւ܂c"""
"""""","""AttributeEvaluators must use the Ranker search ""","""AttributeEvaluatorsRankergpȂ΂Ȃ܂B"""
"""""","""method""","""\bh"""
"""""","""AttributeSelection: Couldn't ""","""AttributeSelection: couldn't"""
"""""","""introspect""","""ȂĂB"""
"""""","""Ranked attributes:\n""",""": \nłƊit܂B"""
"""""","""\nSelected attributes: ""","""\͑nSelected܂: """
"""""","""Selected attributes: ""","""Iꂽ: """
"""""","""Class index out of range.""","""NX͔͈͂܂B"""
"""""","""Can't create Ranker object""","""RankerIuWFNg쐬邱Ƃł܂B"""
"""""","""\n\n=== Attribute Selection on all input data ===\n\n""","""\n\n=== ׂĂ̓̓f[^̑Selection===\n\n"""
"""""","""Search Method:\n""","""@: \n"""
"""""","""\nAttribute ""","""\nAttribute"""
"""""","""Subset Evaluator (""","""W]ҁA("""
"""""","""Evaluator (""","""]ҁA("""
"""""","""supervised, ""","""ē"""
"""""","""Class (""","""NXA("""
"""""","""numeric): ""","""l)A: """
"""""","""nominal): ""","""`A)A: """
"""""","""-h display this help\n""","""-h̏\n\܂B"""
"""""","""-I <name of input file>\n""","""-<̓t@C̖O>\n"""
"""""","""-C <class index>\n""","""-C<NXCfbNX>\n"""
"""""","""\tSets the class index for supervised attribute\n""","""NXēꂽ\nō\tSets"""
"""""","""\tselection. Default=last column.\n""","""\tselectionB Ō̃R ftHg=\n"""
"""""","""-S <Class name>\n""","""-S<NX>\n"""
"""""","""\tSets search method for subset evaluators.\n""","""\tSets͕W]\nŃ\bh{܂B"""
"""""","""-X <number of folds>\n""","""-X<܂ڂ̐>\n"""
"""""","""\tPerform a cross validation.\n""","""Ă鍇@\tPerform\nłB"""
"""""","""-N <random number seed>\n""","""-N<q>\n"""
"""""","""\tUse in conjunction with -X.\n""","""X.\n\tUse"""
"""""","""No search method given.""","""\bh͌^܂łB"""
"""""","""The first argument must be the name of an ""","""ŏ̋c_͖OłɈႢ܂B"""
"""""","""attribute/subset evaluator""","""/W]"""
"""""","""Backward""",""""""
"""""","""Forward""","""]"""
"""""","""Bi-directional""","""o"""
"""""","""Searches the space of attribute subsets by greedy hillclimbing ""","""×~hillclimbingőW̃Xy[X{܂B"""
"""""","""augmented with a backtracking facility. Setting the number of ""","""߂{݂ŁA債܂B ݒ肵܂B"""
"""""","""consecutive non-improving nodes allowed controls the level of ""","""m[hRg[ɃxeA"""
"""""","""backtracking done. Best first may start with the empty set of ""","""sꂽ߂B łǂ1Ԗڂ̓Zbgꂽ󂩂n܂邩܂B"""
"""""","""attributes and search forward, or start with the full set of ""","""ƌtH[hASZbgĂ邱Ƃł̎n"""
"""""","""attributes and search backward, or start at any point and search ""","""|Cgƌ̂ƂɌɌʂƍlāA{A܂͎n܂ĂB"""
"""""","""in both directions (by considering all possible single attribute ""","""̕A(ׂẲ\Ȃ̑l邱ƁB"""
"""""","""additions and deletions at a given point).\n""","""^ꂽ|Cgł̒ǉƍ폜) . \n"""
"""""","""\tDirection of search. (default = 1).""","""\tDirectionB (ftHg=1)."""
"""""","""-D <0 = backward | 1 = forward ""","""-D| <0=1=̃tH[h"""
"""""","""| 2 = bi-directional>""","""| 2 = oA>"""
"""""","""\tNumber of non-improving nodes to""","""m[h\tNumber"""
"""""","""\n\tconsider before terminating search.""","""IO\n\tconsiderB"""
"""""","""\tSize of lookup cache for evaluated subsets.""","""]ꂽŴ߂̃bNAbvLbV\tSizeB"""
"""""","""\n\tExpressed as a multiple of the number of""","""\̔{ƂtExpressed\n"""
"""""","""\n\tattributes in the data set. (default = 1)""","""f[^Zbg\n\tattributesB (ftHg=1)"""
"""""","""Set the maximum size of the lookup cache of evaluated subsets. This is ""","""]ꂽW̃bNAbvLbV̍őTCYݒ肵ĂB ͂łB"""
"""""","""expressed as a multiplier of the number of attributes in the data set. ""","""f[^Zbg̑̐̏搔ƂāA\܂B"""
"""""","""Set the amount of backtracking. Specify the number of ""","""Ԃʂݒ肵ĂB w肵܂B"""
"""""","""Value of -N must be > 0.""",""""""
"""""","""Set the direction of the search.""","""̎wݒ肵ĂB"""
"""""","""\tBest first.\n\tStart set: ""","""\͍ŏɁAtBest܂B\n\tStart̓Zbg܂: """
"""""","""\tSearch direction: ""","""\tSearchw: """
"""""","""backward\n""","""\n"""
"""""","""forward\n""","""Oi\n"""
"""""","""bi-directional\n""","""o\n"""
"""""","""\tStale search after ""","""tStale߂\"""
"""""",""" node expansions\n""",""" m[hg\n"""
"""""","""\tTotal number of subsets evaluated: ""","""W\tTotalԍ͕]܂: """
"""""","""1-last""","""Ō1"""
"""""","""Group: ""","""O[v: """
"""""","""Merit: """,""": """
"""""","""CfsSubsetEval :\n\nEvaluates the worth of a subset of attributes ""","""CfsSubsetEval: \n\nEvaluates͑̕W̉lłB"""
"""""","""by considering the individual predictive ability of each feature ""","""ꂼ̓̌X̗\̔\͂l邱Ƃɂ"""
"""""","""along with the degree of redundancy between them.\n\n""","""̊Ԃ̏璷̓xƋ\n\n"""
"""""","""Subsets of features that are highly correlated with the class ""","""NXƋɔɊ֘A̕W"""
"""""","""while having low intercorrelation are preferred.\n""","""lĂԁAintercorrelationD܂A\n"""
"""""","""\tTreat missing values as a seperate""","""seperateƂĒl𓦂\tTreat"""
"""""","""\n\tvalue.""","""\n\tvalueB"""
"""""","""\tDon't include locally predictive attributes""","""\tDon͋ǏIɗ\̑܂ł܂B"""
"""""","""Identify locally predictive attributes. Iteratively adds ""","""ǏIŗ\̑肵ĂB IterativelyɁA܂B"""
"""""","""attributes with the highest correlation with the class as long ""","""NXł֊֌W鑮"""
"""""","""as there is not already an attribute in the subset that has a ""","""aĂ镔Wɂ͑ɂȂ̂"""
"""""","""higher correlation with the attribute in question""","""͂肵ĂȂ荂֊֌W"""
"""""","""Treat missing as a separate value. Otherwise, counts for missing ""","""ʁX̒lƂĎ蓦ƂĂB łȂ΁A邽߂̃JE
"""""",g"""
"""""","""values are distributed across other values in proportion to their ""","""ls̒ľɕzA"""
"""""","""frequency.""","""pxB"""
"""""","""Stdv :""","""Stdv:"""
"""""","""CFS subset evaluator has not been built yet\n""","""A\nCFSW]҂ɌĂĂ܂B"""
"""""","""\tCFS Subset Evaluator\n""","""\tCFSW]\n"""
"""""","""\tTreating missing values as a seperate value\n""","""seperatel\nƂČltTreating\"""
"""""","""\tIncluding locally predictive attributes\n""","""ǏIŗ\̑\ntIncluding\"""
"""""","""ChiSquaredAttributeEval :\n\nEvaluates the worth of an attribute ""","""ChiSquaredAttributeEval: \n\nEvaluates͑̉lłB"""
"""""","""by computing the value of the chi-squared statistic with respect to the class.\n""","""NXɊւăL[œ悳ꂽvl̒lvZ邱Ƃɂ\n"""
"""""","""Chi-squared attribute evaluator has not been built""","""L[œ悳ꂽ]҂͌ĂĂ܂B"""
"""""","""\tChi-squared Ranking Filter""","""\tChiɂē悳ꂽ̃tB^"""
"""""","""Click to set hold out or ""","""܂̓NbNāAێoĂB"""
"""""","""test instances""","""eXgCX^X"""
"""""","""Evaluates attribute subsets on training data or a seperate ""","""g[jOf[^seperateőW]܂B"""
"""""","""hold out testing set""","""u񋟂ĂB"""
"""""","""\tclass name of the classifier to use for""","""\͎gpNVt@CA̖Otclass܂B"""
"""""","""\n\teg. -C weka.classifiers.bayes.NaiveBayes ... ""","""\n~̐2Nڂ̗rB -C weka.classifiers.bayes.NaiveBayesc"""
"""""","""-B <classifier>""","""-B<NVt@CA>"""
"""""","""\tUse the training data to estimate""","""\tUse͌ςg[jOf[^łB"""
"""""",""" accuracy.""",""" xB"""
"""""","""\tName of the hold out/test set to ""","""ZbgꂽێAEg/eXg\tName"""
"""""","""\n\testimate accuracy on.""","""\xtestimate\nB"""
"""""","""-H <filename>""","""-H<t@C>"""
"""""","""A classifier must be specified with -B option""","""-BIvVŃNVt@CAw肵Ȃ΂Ȃ܂B"""
"""""","""File containing hold out/test instances.""","""t@CܗĹACX^X񋟂邩A܂̓eXg܂B"""
"""""","""Use training data instead of hold out/test instances.""","""ێAEg/eXgCX^X̑Ƀg[jOf[^gpĂB"""
"""""","""Hold out/test set is not compatable with ""","""eXgEZbgcompatablełȂ/񋟂ĂB"""
"""""","""training data.""","""f[^P܂B"""
"""""","""Must specify a set of hold out/test instances ""","""K{1Zbg̕ێAEg/eXgCX^Xw肵܂B"""
"""""","""with -H""","""-HƋ"""
"""""","""evaluateSubset : Incompatable instance types.""","""evaluateSubset: IncompatableCX^X^CvB"""
"""""","""\tClassifier subset evaluator has not been built yet\n""","""A\n\tClassifierW]҂ɌĂĂ܂B"""
"""""","""\tClassifier Subset Evaluator\n""","""\tClassifierW]\n"""
"""""","""\tHold out/test set: ""","""\tHoldAEg/eXg̓Zbg܂: """
"""""","""Click to set""","""Zbgɂ́ANbNĂB"""
"""""","""none\n""","""ȂɂA\n"""
"""""","""Training data\n""","""g[jOf[^\n"""
"""""","""\tAccuracy estimation: MAE\n""","""\tAccuracyς: MAE\n"""
"""""","""Click to set hold out or test instances""","""NbNāAێoA܂̓CX^XeXgĂB"""
"""""","""ConsistencySubsetEval :\n\nEvaluates the worth of a subset of ""","""ConsistencySubsetEval: \n\nEvaluatesAW̉l"""
"""""","""attributes by the level of consistency in the class values when the ""","""KlɂAѐ̃xŁAʂƍl邩B"""
"""""","""training instances are projected onto the subset of attributes. ""","""g[jO͑̕WɉfoĂ܂B"""
"""""","""\n\nConsistency of any subset can never be lower than that of the ""","""ǂȕW\n\nConsistencyႢ͂܂B"""
"""""","""full set of attributes, hence the usual practice is to use this ""","""SȃZbg̑łAāAP͂gp邱ƂɂȂĂ܂B"""
"""""","""subset evaluator in conjunction with a Random or Exhaustive search ""","""RandomExhaustiveɊ֘AW]"""
"""""","""which looks for the smallest subset with consistency equal to that ""","""ǂꂪƓѐłWT܂B"""
"""""","""of the full set of attributes.\n""","""SȃZbg\nɂ"""
"""""","""Consistency subset evaluator requires a class ""","""ѐW]҂̓NXKvƂ܂B"""
"""""","""attribute!""","""ʂƍlĂ!"""
"""""","""Consistency subset evaluator can't handle a ""","""ѐW]҂aƂł܂B"""
"""""","""numeric class attribute!""","""lNX!"""
"""""","""A subset should not contain the class!""","""W̓NX܂ނׂł͂܂!"""
"""""","""\tConsistency subset evaluator has not been built yet\n""","""A\n\tConsistencyW]҂ɌĂĂ܂B"""
"""""","""\tConsistency Subset Evaluator\n""","""\tConsistencyW]\n"""
"""""","""ExhaustiveSearch : \n\nPerforms an exhaustive search through ""","""ExhaustiveSearch: \n\͒ʂēOIȌnPerforms܂B"""
"""""","""the space of attribute subsets starting from the empty set of ""","""󂩂̎n߂ZbgW̃Xy[X"""
"""""","""attrubutes. Reports the best subset found. If a start set is ""","""attrubutesB łǂW|[gB X^[gZbgȂ"""
"""""","""supplied, the algorithm searches backward from the start point ""","""ĂāAASY͌ɃX^[g|CgT܂B"""
"""""","""and reports the smallest subset with as good or better evaluation ""","""|[g͓炢ǂAǂ]łW܂B"""
"""""","""as the start point.\n""","""n߂Ƃ. \nwĂB"""
"""""","""\n\tExhaustive search stops after""","""tExhaustive~{\n\"""
"""""","""\n\tfinding the smallest possible subset""","""tfinding钆ŉ\ȕWł\n\"""
"""""","""\n\twith merit as good as or better than""","""炢܂́A\n\͓炢ǂԂŒ悭twith܂B"""
"""""","""\n\tthe start set.""","""n~\ttheAn߂̓Zbg܂B"""
"""""","""\tExhaustive Search.\n\tStart set: ""","""\tExhaustive\n\tStart̓Zbg܂: """
"""""","""\tNumber of evaluations: ""","""]\tNumber: """
"""""","""Zero feature subset (""","""[WA("""
"""""","""temp""","""Վ"""
"""""","""by measuring the gain ratio with respect to the class.\n\n""","""肷. \n\nNXɊւ䗦ɊlĂB"""
"""""","""GainR(Class, Attribute) = (H(Class) - H(Class | Attribute)) / ""","""GainR(NXA)=(H(NX)--H(NX| ))/"""
"""""","""H(Attribute).\n""","""H(ʂƍl)\n"""
"""""","""\tGain Ratio evaluator has not been built""","""\tGain Ratio]҂͌ĂĂ܂B"""
"""""","""\tGain Ratio feature evaluator""","""\tGain Ratio͕]҂W܂B"""
"""""","""If supplied, the starting set becomes""","""ȂAn߂̃Zbg͂Ȃ܂B"""
"""""","""\n\tone member of the initial random""","""\n\͏̃o[ɖׂ̏ԂŒqς܂B"""
"""""","""\n\tpopulation.""","""\n\tpopulationB"""
"""""","""\tSet the size of the population.""","""l̃TCY\tSetB"""
"""""","""\n\t(default = 10).""","""\n\t(ftHg=10)B"""
"""""","""-Z <population size>""","""-Z<lTCY>"""
"""""","""\tSet the number of generations.""","""\͐̐tSet܂B"""
"""""","""\n\t(default = 20)""","""\n\t(ftHg=20)"""
"""""","""-G <number of generations>""","""-G<̐>"""
"""""","""\tSet the probability of crossover.""","""f̊m\tSetB"""
"""""","""\n\t(default = 0.6)""","""\n\t(ftHg=0.6)"""
"""""","""-C <probability of""","""-C<m"""
"""""",""" crossover>""",""""""
"""""","""\tSet the probability of mutation.""","""ψق̊m\tSetB"""
"""""","""\n\t(default = 0.033)""","""\n\t(ftHg=0.033)"""
"""""","""-M <probability of mutation>""","""-M<ψق̊m>"""
"""""","""\tSet frequency of generation reports.""","""\tSetpx͕񍐂܂B"""
"""""","""\n\te.g, setting the value to 5 will ""","""5ɒlݒ肷\n\te.g͂ł傤B"""
"""""","""\n\t report every 5th generation""","""\n\t5Ԗڂ̐㖈񍐂܂B"""
"""""","""\n\t(default = number of generations)""","""\n\t(̃ftHg=)"""
"""""","""-R <report frequency>""","""-R<|[gpx>"""
"""""","""\tSet the random number seed.""","""\tSetB"""
"""""","""Set a start point for the search. This is specified as a comma ""","""ɃX^[g|Cgݒ肵ĂB ̓R}ƂĎw肳܂B"""
"""""","""ranges. Eg. 1,2,5-9,17. The start set becomes one of the population ""","""͈́B Ⴆ 1,2,5-9,17. X^[gZbg͐l1ɂȂ܂B"""
"""""","""members of the initial population.""","""̐l̃o[B"""
"""""","""Set the random seed.""","""ׂ̎qݒ肵ĂB"""
"""""","""Set how frequently reports are generated. Default is equal to ""","""ǂꂭ炢pɂɐݒ肳āA|[g͔Ă܂B ftHg͓łB"""
"""""","""the number of generations meaning that a report will be printed for ""","""|[g邻Ӗ鐢̐"""
"""""","""initial and final generations. Setting the value to 5 will result in ""","""IAāAŏIIȐB 5ւ̒l炷ݒ"""
"""""","""a report being printed every 5 generations.""","""5㖈Ɉ郌|[gB"""
"""""","""Set the probability of mutation occuring.""","""ψّ݂̊mݒ肵ĂB"""
"""""","""Set the probability of crossover. This is the probability that ""","""f̊mݒ肵ĂB ꂪmłA"""
"""""","""two population members will exchange genetic material.""","""2l̐lo[`q̍ޗł傤B"""
"""""","""Set the number of generations to evaluate.""","""]鐢̐ݒ肵ĂB"""
"""""","""Set the population size. This is the number of individuals ""","""lTCYݒ肵ĂB ͌l̐łB"""
"""""","""(attribute sets) in the population.""","""(Zbg) lŁB"""
"""""","""GeneticSearch :\n\nPerforms a search using the simple genetic ""","""GeneticSearch: ȒPgpn~\nPerforms aA`q"""
"""""","""algorithm described in Goldberg (1989).\n""","""S[ho[O(1989)\nŐꂽASY"""
"""""","""\tGenetic search.\n\tStart set: ""","""\tGenetic͒T܂B\n\tStart̓Zbg܂: """
"""""","""\tPopulation size: ""","""\tPopulationTCY: """
"""""","""\n\tNumber of generations: ""","""\n\tNumber: """
"""""","""\n\tProbability of crossover: ""","""f\n\tProbability: """
"""""","""\n\tProbability of mutation: ""","""ψق\n\tProbability: """
"""""","""\n\tReport frequency: ""","""n~\tReportpx: """
"""""","""\n\tRandom number seed: ""","""n~\tRandomAɎ܂: """
"""""","""Problem in population init""","""lCjbgɂ"""
"""""","""\nInitial population\n""","""\nInitiall\n"""
"""""","""\nGeneration: """,""""""
"""""","""merit   \tscaled  \tsubset\n""","""\\tsubset\ntscaled܂B"""
"""""","""GreedyStepwise :\n\nPerforms a greedy forward or backward search ""","""GreedyStepwise: \n\nPerforms͑O×~ł邩̌łB"""
"""""","""through ""","""˂"""
"""""","""the space of attribute subsets. May start with no/all attributes or from ""","""W̃Xy[XB ܂ׂ͂ĂʂƍlȂ/Sn߂邩ȂB"""
"""""","""an arbitrary point in the space. Stops when the addition/deletion of any ""","""Xy[X̔Cӂ̃|CgB ̓Y/폜ł邱Ƃ̒~"""
"""""","""remaining attributes results in a decrease in evaluation. ""","""̂܂܂ŎcĂ͕̂]̌炵܂B"""
"""""","""Can also produce a ranked list of ""","""܂AitꂽXgoƂł܂B"""
"""""","""attributes by traversing the space from one side to the other and ""","""Ĉ̑瑼̑փXy[Xf̂ɂ鑮B"""
"""""","""recording the order that attributes are selected.\n""","""ꂪʂƍlI[_[L^̂IA\n"""
"""""","""Search backwards rather than forwards.""","""OłƂނɒTĂB"""
"""""","""Set to true if a ranked list is required.""","""itꂽXgKvłȂA{ɃZbgĂB"""
"""""","""\tUse a backward search instead  of a""","""ȃ\tUse atT"""
"""""","""\n\tforward one.""","""\n\AtforwardA1B"""
"""""","""\tProduce a ranked list of attributes.""","""\tProducea͑̃Xgit܂B"""
"""""","""\n\tUse in conjuction with -R""","""-Rconjuction\n\tUse"""
"""""","""\tGreedy Stepwise (""","""\XtGreedyA("""
"""""","""backwards)""",""")"""
"""""","""forwards)""","""tH[h)"""
"""""",""".\n\tStart set: """,""".. \n\tStart̓Zbg܂: """
"""""","""all attributes\n""","""ׂĂ̑\n"""
"""""","""passed by""","""ʂ߂܂B"""
"""""","""can be ranked.""","""it邱Ƃł܂B"""
"""""","""InfoGainAttributeEval :\n\nEvaluates the worth of an attribute ""","""InfoGainAttributeEval: \n\nEvaluates͑̉lłB"""
"""""","""by measuring the information gain with respect to the class.\n\n""","""񂪃NXɊւ. \n\nl鑪"""
"""""","""InfoGain(Class,Attribute) = H(Class) - H(Class | Attribute).\n""","""InfoGain(NXA)=H(NX)--H(NX| )\n"""
"""""","""\tjust binarize numeric attributes instead\n ""","""\tjust binarizel͑\nʂƍl܂B"""
"""""","""\tof properly discretizing them.""","""\͓K؂ɗUtof܂BB"""
"""""","""Just binarize numeric attributes instead of properly discretizing them.""","""̑ɂAlbinarizeAK؂łAUAB"""
"""""","""Information Gain attribute evaluator has not been built""","""Gain]҂͌ĂĂ܂B"""
"""""","""\tInformation Gain Ranking Filter""","""\tInformation͊̃tB^l܂B"""
"""""","""\n\tNumeric attributes are just binarized""","""n~\tNumericA͂binarized܂B"""
"""""","""OneRAttributeEval :\n\nEvaluates the worth of an attribute by ""","""OneRAttributeEval: \n\nEvaluatesẢl"""
"""""","""using the OneR classifier.\n""","""gpAOneRNVt@CA\n"""
"""""","""Set the seed for use in cross validation.""","""Ă鍇@ɂgp̂߂̎qݒ肵ĂB"""
"""""","""Set the number of folds for cross validation.""","""Ă鍇@ɐ܂ڂ̐ݒ肵ĂB"""
"""""","""Use the training data to evaluate attributes rather than ""","""g[jOf[^gpāAނ둮]ĂB"""
"""""","""cross validation.""","""@ɌĂB"""
"""""","""The minimum number of objects in a bucket ""","""oPc̒̍̕ŏ̐"""
"""""","""(passed to OneR).""","""(OneRɒʂ)łB."""
"""""","""\tRandom number seed for cross validation (default = 1)""","""\tRandomԍɌĂ鍇@̂߂Ɏ܂B(ftHg=1)"""
"""""","""\tNumber of folds for cross validation (default = 10)""","""Ă鍇@̂߂̐܂ڂ\tNumber(ftHg=10)"""
"""""","""-F <folds>""","""-F<܂>"""
"""""","""\tUse training data for evaluation rather than cross validaton""","""validatonɌĂނ]̂߂̃f[^P\tUse"""
"""""","""\tMinimum number of objects in a bucket (passed on to ""","""oPc̒̕\tMinimumԍA(ʂ܂B"""
"""""","""OneR, default = 6)""","""OneRAftHg=6)"""
"""""","""\tOneR feature evaluator has not been built yet""","""\tOneR]҂͂܂ĂĂ܂B"""
"""""","""\tOneR feature evaluator.\n\n""","""\tOneR]\n\n"""
"""""","""\tUsing ""","""\tUsing"""
"""""","""training data for evaluation of attributes.""","""̕]̂߂̃f[^P܂B"""
"""""",""" fold cross validation for evaluating """,""" ]̂߂̌Ă鍇@܂d˂ĂB"""
"""""","""\n\tMinimum bucket size for OneR: ""","""OneR̂߂n~\tMinimumoPcTCY: """
"""""","""Performs a principal components analysis and transformation of ""","""听͂ƕωs܂B"""
"""""","""the data. Use in conjunction with a Ranker search. Dimensionality ""","""f[^B RankerɊ֘AāAgp܂B """
"""""","""reduction is accomplished by choosing enough eigenvectors to ""","""\ȌŗLxNgIԂƂɂČDĂB"""
"""""","""account for some percentage of the variance in the original data---""","""IWĩf[^̕ω̉炩̊߂ĂB---"""
"""""","""default 0.95 (95%). Attribute noise can be filtered by transforming ""","""0.95(95%)ɃftHgƂĂB ό`邱ƂɂāAGtB^[
"""""",ɂ邱Ƃł܂B"""
"""""","""to the PC space, eliminating some of the worst eigenvectors, and ""","""čłŗLxNĝrPCXy[XɁB"""
"""""","""then transforming back to the original space.""","""āÃXy[Xɕό`Ė߂܂B"""
"""""","""\tDon't normalize input data.""","""\tDon͓̓f[^𐳏ɂ܂B"""
"""""","""\tRetain enough PC attributes to account ""","""邱Ƃł邭炢\tRetain PC"""
"""""","""\n\tfor this proportion of variance in ""","""̕ω̂̊\n\tfor"""
"""""","""the original data. (default = 0.95)""","""IWĩf[^B (ftHg=0.95)"""
"""""","""\tTransform through the PC space and ""","""PCXy[Xʂ\tTransformB"""
"""""","""\n\tback to the original space.""","""̃Xy[Xւ\n\tbackB"""
"""""","""\tMaximum number of attributes to include in ""","""tMaximumtԂ钆Ɋ܂ł鑮\"""
"""""","""\ntransformed attribute names. (-1 = include all)""","""\͑ntransformed܂B (-1=ׂ͂Ă܂ł܂)"""
"""""","""Normalize input data.""","""̓f[^𐳏ɂĂB"""
"""""","""Retain enough PC attributes to account for this proportion of ""","""̊邱Ƃł邭炢PCۗLĂB"""
"""""","""variance.""","""ωB"""
"""""","""Transform through the PC space and back to the original space. ""","""PCXy[XʂČ̃Xy[Xɕό`Ė߂ĂB"""
"""""","""If only the best n PCs are retained (by setting varianceCovered < 1) ""","""łǂn PCۗLꂳꍇA悩ł傤B(varianceCovered<1ݒ肷̂ɂ) """
"""""","""then this option will give a dataset in the original space but with ""","""̃IvV̂IWi؂f[^Zbg^邻̎"""
"""""","""less attribute noise.""","""ȉ͎Gʂƍl܂B"""
"""""","""Problem with eigenvektors!!!""","""eigenvektorsɊւ!"""
"""""","""***** everything's fine !!!""","""***** ׂĂ΂炵ł!"""
"""""","""Principal components hasn't been built yet""","""听͂܂ĂĂ܂B"""
"""""","""Correlation matrix\n""","""֍s\n"""
"""""","""eigenvalue\tproportion\tcumulative\n""","""ŗLl\tproportion\tcumulative\n"""
"""""","""\nEigenvectors\n""",""""""
"""""","""\nPC space transformed back to original space.\n""","""̃Xy[XnPCXy[XςԂ\\n"""
"""""","""(Note: can't evaluate attributes in the original ""","""(ȉɒӂĂAāAIWiő]邱Ƃł܂B"""
"""""","""space)\n""","""Xy[X) \n"""
"""""","""Principal components hasn't been built yet!""","""听͂܂ĂĂ܂!"""
"""""","""\tPrincipal Components Attribute Transformer\n\n""","""\tPrincipalR|[lgψ\n\n"""
"""""","""convertInstance: Principal components not ""","""convertInstance: 听"""
"""""","""built yet""","""܂ĂĂ܂B"""
"""""","""Can't convert instance: header's don't match: ""","""CX^Xϊ邱Ƃł܂: wb_[͍̂̂܂: """
"""""","""PrincipalComponents""",""""""
"""""","""->PC->original space""","""->PC->̃Xy[X"""
"""""","""_principal components""","""_听"""
"""""","""Forward selection race""","""OȋI[X"""
"""""","""Backward elimination race""","""̏[X"""
"""""","""Schemata race""","""Schemata[X"""
"""""","""Rank race""","""N[X"""
"""""","""10 Fold""","""10 ܂"""
"""""","""Races the cross validation error of competing ""","""Ă鍇@̋܂B"""
"""""","""attribute subsets. Use in conjuction with a ClassifierSubsetEval. ""","""WʂƍlĂB conjuctionł́AClassifierSubsetEvalƋɎgp܂B"""
"""""","""RaceSearch has four modes:\n\nforward selection ""","""RaceSearchɂ4̃[h: \n\nforwardɂAI"""
"""""","""races all single attribute additions to a base set (initially ""","""x[Xւׂ̂Ă̂̑ǉݒ肷郌[XA(߂ɁB"""
"""""",""" no attributes), selects the winner to become the new base set """,""" ܂)A҂Vx[XZbgɂȂ̂I܂B"""
"""""","""and then iterates until there is no improvement over the base set. ""","""āAāAx[XZbg̉ǂSȂ܂ŁAJԂ܂B"""
"""""","""\n\nBackward elimination is similar but the initial base set has all ""","""n~\nBackwardAlłÃx[XZbgɁAׂĂ܂B"""
"""""","""attributes included and races all single attribute deletions. ""","""́AׂĂ̂̑폜܂ŁA܂B"""
"""""","""\n\nSchemata search is a bit different. Each iteration a series of ""","""nSchemata{\n\͏قȂĂ܂B ꂼ̌JԂaV[Y"""
"""""","""races are run in parallel. Each race in a set determines whether ""","""[X͂łBsɗ₵ĂB Zbgɂe[X͌肵܂B"""
"""""","""a particular attribute should be included or not---ie the race is ""","""̑͊܂܂ׂłB---ieA[X͂łB"""
"""""","""between the attribute being ""in"" or ""out"". The other attributes ""","""""in""""out""ł鑮̊ԂŁB ̑"""
"""""","""for this race are included or excluded randomly at each point in the ""","""Ŋe|CgŎ蓖肵Ɋ܂܂ĂA܂͏ꂽ̃[X"""
"""""","""evaluation. As soon as one race ""","""]B 1̃[X̎"""
"""""","""has a clear winner (ie it has been decided whether a particular ""","""҂ĂA(ieɁAał邩ۂɊ֌WȂA͒܂Ă܂B"""
"""""","""attribute should be inor not) then the next set of races begins, ""","""inorɂׂłȂA)AāA[X̎̃Zbg͎n܂܂B"""
"""""","""using the result of the winning race from the previous iteration as ""","""ǑJԂ̏[X̌ʂgp܂B"""
"""""","""new base set.\n\nRank race first ranks the attributes using an ""","""n~̐Vx[XZbg\nRankA[X́AŏɁAgp邱Ƃőit܂B"""
"""""","""attribute evaluator and then races the ranking. The race includes ""","""]҂ʂƍlāALO͂̎A܂B [XCN[h"""
"""""","""no attributes, the top ranked attribute, the top two attributes, the ""","""ȂAʂ̑Agbv2̑"""
"""""","""top three attributes, etc.\n\nIt is also possible to generate a ""","""܂Agbv3̑AȂ\n\nIta𔭐̂ɂĉ\łB"""
"""""","""raked list of attributes through the forward racing process. ""","""Oĩ[XvZXʂđ̃Xg~W߂܂B"""
"""""","""If generateRanking is set to true then a complete forward race will ""","""generateRanking{ɐݒ肳ƁASȑOĩ[X͂ł傤B"""
"""""","""be run---that is, racing continues until all attributes have been ""","""ĂB---ׂĂ̑܂ŁAȂ킿A[X͑܂B"""
"""""","""selected. The order that they are added in determines a complete ""","""IɂB 炪I[_[͊SȏԂa肵܂B"""
"""""","""ranking of all the attributes.\n\nRacing uses paired and unpaired """,""".. \n\nRacinggp邷ׂĂ̑̃LÓA΂ɂāA΂ɂ܂B"""
"""""","""t-tests on cross-validation errors of competing subsets. When there ""","""Ă镔W̌Ă鍇@t-eXgB ̂"""
"""""","""is a significant difference between the means of the errors of two ""","""2̌̎i̊Ԃɂ́AdvȈႢ܂B"""
"""""","""competing subsets then the poorer of the two can be eliminated from ""","""ɁA2̂̂ɂāAn̂r邱Ƃł鋣Ă镔W"""
"""""","""the race. Similarly, if there is no significant difference between ""","""[XB lłAǂȏdvȈႢԂɂ܂B"""
"""""","""the mean errors of two competing subsets and they are within some ""","""2̋Ă镔W̕ό덷Ƃ͂܂B"""
"""""","""threshold of each other, then one can be eliminated from the race. ""","""[X݂̕~A1r邱Ƃł܂B"""
"""""","""Set the type of search.""","""̃^Cvݒ肵ĂB"""
"""""","""Set the significance level to use for t-test comparisons.""","""t-eXgr̗prɗLӐݒ肵ĂB"""
"""""","""Set the error threshold by which to consider two subsets ""","""2̕Wl~ݒ肵ĂB"""
"""""","""equivalent.""","""B"""
"""""","""Set the number of folds to use for x-val error estimation. ""","""x-val茩ςɎgp܂ڂ̐ݒ肵ĂB"""
"""""","""Leave-one-out is selected automatically for schemata search.""","""1ȂĂBschematâ߂ɎIɑI܂B"""
"""""","""Turn on verbose output for monitoring the search's progress.""","""̐ij^[邽߂̏璷ȏo͂ĂB"""
"""""","""Attribute evaluator to use for generating an initial ranking. ""","""̃LO𐶐̂Ɏgp]҂ʂƍlĂB"""
"""""","""Use in conjunction with a rank race""","""N[XɊ֘Agp"""
"""""","""Use the racing process to generate a ranked list of attributes. ""","""[XvZXgpāÅitꂽXg𐶐ĂB"""
"""""","""Using this mode forces the race to be a forward type and then races ""","""̃[hgp̂́A[XtH[hE^CvƎɁA[Xł邱Ƃ܂B"""
"""""","""until all attributes have been added, thus giving a ranked list""","""ׂĂ̑āǍʁAitꂽXg^܂"""
"""""","""Specify the number of attributes to retain. Use in conjunction ""","""ۗL鑮̐w肵ĂB ڑɂgp"""
"""""","""with generateRanking. The default value ""","""generateRankingƋɁB ftHgl"""
"""""","""results in no attributes being discarded. Use in conjunction with ""","""̂ĂȂɂSʁB Ɋ֘AĎgpB"""
"""""","""generateRanking""","""generateRanking܂B"""
"""""","""\tType of race to perform.\n\t""",""".. \n\ts郌[X\tType"""
"""""","""(default = 0).""","""(ftHg=0)."""
"""""","""-R <0 = forward | 1 = backward ""","""-R<0=| 1=ɑ܂B"""
"""""","""race | 2 = schemata | 3 = rank>""","""[X| 2=schemata| 3=N>"""
"""""","""\tSignificance level for comaparisons""","""tSignificancecomaparisonŝ߂ɕɂ\"""
"""""","""\n\t(default = 0.001(forward/backward/""","""\n\tA(ftHg=0.001A(forward/backward/"""
"""""","""-L <significance>""","""-L<Ӗ>"""
"""""","""\tThreshold for error comparison.\n\t""","""r\n\t\tThreshold"""
"""""","""(default = 0.001).""","""(ftHg=0.001)."""
"""""","""\tAttribute ranker to use if doing a ""","""gp邽߂ɂ\tAttribute胉ŃAAĂa"""
"""""","""\n\trank search. Place any\n\t""","""n~\trankATĂB n~t\uĂB"""
"""""","""evaluator options LAST on the""","""]҂LASTɂ䂾˂܂B"""
"""""","""-- -M.\n\t(default = GainRatioAttributeEval)""","""-- -M.\n\t(ftHg=GainRatioAttributeEval)"""
"""""","""\tFolds for cross validation\n\t""","""Ă鍇@\n\t\tFolds"""
"""""","""(default = 0 (1 if schemata race)""","""(ftHg=0(1schematałȂ狣܂)"""
"""""","""-F <0 = 10 fold | 1 = leave-one-out>""","""-F<0 = 10 ܂dȂĂ| O1=̋x-1>"""
"""""","""\tGenerate a ranked list of attributes.""","""\tGeneratea͑̃Xgit܂B"""
"""""","""\n\tForces the search to be forward\n.""","""\n\́AOi\nɂȂ悤ɌtForces܂B"""
"""""","""\tand races until all attributes have\n""","""\nׂĂ̑ɂ܂ŁA\tand͋܂B"""
"""""","""\tselected, thus producing a ranking.""","""\tselectedāǍʁALO𐶎Y܂B"""
"""""","""\tSpecify number of attributes to retain from ""","""\͕ۗL鑮̐tSpecify܂B"""
"""""","""\n\tthe ranking. Overides -T. Use ""","""n~\ttheLOB Overides-TB gp"""
"""""","""in conjunction with -Q""","""-QɊ֘A"""
"""""","""\n\tmay be discarded from the ranking.""","""̂ĂāA\n\̓LOtmay܂B"""
"""""","""\n\tUse in conjuction with -Q""","""-Qconjuction\n\tUse"""
"""""","""\tVerbose output for monitoring the ""","""\tVerbose̓j^[̂߂ɏo͂܂B"""
"""""","""search.""","""TĂB"""
"""""","""Subset evaluator! (RaceSearch)""","""W]! (RaceSearch)"""
"""""","""Can't use an unsupervised subset evaluator ""","""ē󂯂ȂW]҂gp邱Ƃł܂B"""
"""""","""Must use a HoldOutSubsetEvaluator, eg. ""","""K{͗ႦHoldOutSubsetEvaluatorgp܂B"""
"""""","""weka.attributeSelection.ClassifierSubsetEval ""","""weka.attributeSelection.ClassifierSubsetEval"""
"""""","""Only error based subset evaluators can be used, ""","""ɊÂĂ镔W]҂gp邱Ƃł܂B"""
"""""","""eg. weka.attributeSelection.ClassifierSubsetEval ""","""Ⴆ΁Aweka.attributeSelection.ClassifierSubsetEval"""
"""""","""(RaceSearch)""",""""""
"""""","""All instances have missing class! (RaceSearch)""","""ׂĂ̗ɂ́AĂNX܂! (RaceSearch)"""
"""""","""More attributes requested than exist in the data ""","""葽̑vAf[^ł́A݂Ă܂B"""
"""""","""(RaceSearch).""",""""""
"""""","""Need to request a ranked list of attributes ""","""̊itꂽXgvKv"""
"""""","""before attributes can be ranked (RaceSearch).""","""ȑOAit邱Ƃł܂(RaceSearch)B"""
"""""","""Search must be performed before attributes ""","""̑OɌsȂ΂Ȃ܂B"""
"""""","""can be ranked (RaceSearch).""","""it邱Ƃł܂(RaceSearch)B"""
"""""","""raceSchemata: No clear winner after sampling ""","""raceSchemata: W{ǒ̊҂܂B"""
"""""","""Random subset: ""","""ׂ̕W: """
"""""","""Matched ""","""킹Ă܂B"""
"""""","""Prob :""","""Prob:"""
"""""","""contender 0 won ""","""0͏܂B"""
"""""","""contender 1 won""","""1͏܂B"""
"""""","""Means : """,""": """
"""""","""Evaluations so far : ""","""ƂĂ]: """
"""""","""Next sets:\n""","""̃Zbg: \n"""
"""""","""Total evaluations : ""","""]vĂ: """
"""""","""Initial sets:\n""","""̃Zbg: \n"""
"""""","""Next set : \n""","""̏W: \n"""
"""""","""RaceSearch: problem in hillClimbRace""","""RaceSearch: hillClimbRace̖"""
"""""","""Eliminating (identical) ""","""r܂B()łB """
"""""","""Eliminating (near identical) ""","""r܂B(߂) """
"""""",""" evaluations\n""",""" ]\n"""
"""""",""" diff : """,""" ft: """
"""""","""Eliminating (-worse) ""","""r܂B(-Ђǂ) """
"""""","""Eliminating (worse) ""","""r܂B(Ђǂ) """
"""""",""" after """,""" """
"""""",""" evaluations""",""" ]"""
"""""","""\nerror ""","""\nerror"""
"""""","""*****eliminated count: ""","""*****rꂽJEg: """
"""""","""Remaining error: ""","""cĂ: """
"""""","""Best set from race : ""","""[Xł悭ZbgĂ: """
"""""",""" Processed : """,""" : """
"""""","""\tRaceSearch.\n\tRace type : ""","""\tRaceSearch\n\tRace̓^Cv܂: """
"""""","""forward selection race\n\tBase set : no attributes""","""OɁAI[X\n\tBase̓Zbg܂: ܂B"""
"""""","""backward elimination race\n\tBase set : all attributes""","""ɁA[X\n\tBase̓Zbg܂: ׂĂ̑"""
"""""","""schemata race\n\tBase set : no attributes""","""schemata[X\n\tBase̓Zbg܂: ܂B"""
"""""","""rank race\n\tBase set : no attributes\n\t""","""N[X\n\tBase̓Zbg܂: \n\܂tB"""
"""""","""Attribute evaluator : ""","""]҂ʂƍlĂ: """
"""""","""\n\tCross validation mode : ""","""n~\tCross@[h: """
"""""","""10 fold""","""10܂"""
"""""","""Leave-one-out""","""1ȂĂB"""
"""""","""\n\tMerit of best subset found : ""","""łǂW\n\tMerit͌܂: """
"""""","""RandomSearch : \n\nPerforms a Random search in ""","""RandomSearch: RandomT\n\nPerforms"""
"""""","""the space of attribute subsets. If no start set is supplied, Random ""","""W̃Xy[XB RandomAX^[gZbgSȂȂ"""
"""""","""search starts from a random point and reports the best subset found. ""","""ׂ̓_ƍłǂW|[gn߂{ĂB"""
"""""","""If a start set is supplied, Random searches randomly for subsets ""","""X^[gZbgȂARandom͎蓖肵ɕW{߂܂B"""
"""""","""that are as good or better than the start point with the same or ""","""܂͓炢ǂA܂͓炢X^[g|CgǂB"""
"""""","""or fewer attributes. Using RandomSearch in conjunction with a start ""","""܂́A菭ȂB n߂Ɋ֘ARandomSearchgp܂B"""
"""""","""set containing all attributes equates to the LVF algorithm of Liu ""","""ׂĂ̑܂ރZbgELVFASYɈvĂ܂B"""
"""""","""and Setiono (ICML-96).\n""","""Setiono(ICML-96)āA\n"""
"""""","""\n\tIf a start point is supplied,""","""n~\tIfAX^[g|Cg܂B"""
"""""","""\n\trandom search evaluates the start""","""n~\trandomA͎n߂]܂B"""
"""""","""\n\tpoint and then randomly looks for""","""tpointƂ̎蓖肵ɒT\n\"""
"""""","""\n\tsubsets that are as good as or better""","""炢܂́A\炢ǂ\n\tsubsets"""
"""""","""\n\tthan the start point with the same""","""n߂炢Ŏw\n\tthan"""
"""""","""\n\tor lower cardinality.""","""\n\torႢB"""
"""""","""\tPercent of search space to consider.""","""l錟Xy[X\tPercentB"""
"""""","""\n\t(default = 25%).""","""\n\t(25ftHg=%)B"""
"""""","""-F <percent> ""","""-F<p[Zg>"""
"""""","""\tOutput subsets as the search progresses.""","""ƂĂ\tOutputW͐i܂B"""
"""""","""\n\t(default = false).""","""\n\t(= UŃftHgƂ܂)B"""
"""""","""Set the start point for the search. This is specified as a comma ""","""ɃX^[g|Cgݒ肵ĂB ̓R}ƂĎw肳܂B"""
"""""","""ranges. Eg. 1,2,5-9,17. If specified, Random searches for subsets ""","""͈́B Ⴆ 1,2,5-9,17. w肳ȂARandom͕W{߂܂B"""
"""""","""of attributes that are as good as or better than the start set with ""","""炢܂́An߂ɂZbg\炢ǂɂ"""
"""""","""the same or lower cardinality.""","""ł邩̊B"""
"""""","""Print progress information. Sends progress info to the terminal ""","""iĂB iCtH[V[ɑ܂B"""
"""""","""as the search progresses.""","""îŁB"""
"""""","""Percentage of the search space to explore.""","""T錟Xy[X̊B"""
"""""","""\tRandom search.\n\tStart set: ""","""\tRandom͒T܂B\n\tStart̓Zbg܂: """
"""""","""no attributes\n""","""\܂nB"""
"""""","""\tNumber of iterations: ""","""JԂ\tNumber: """
"""""","""% of the search space)\n""","""Xy[X%) \n"""
"""""","""\tMerit of best subset found: ""","""łǂW\tMerit͌܂: """
"""""","""Initial subset (""","""̕WA("""
"""""","""New best subset (""","""VłǂWA("""
"""""","""% done""","""%A"""
"""""","""Ranker : \n\nRanks attributes by their individual evaluations. ""","""胉N: ނ̌X̕]ɂn~\nRanksB"""
"""""","""Use in conjunction with attribute evaluators (ReliefF, GainRatio, ""","""]҂Ɋ֘AgpA(ReliefFAGainRatio"""
"""""","""Entropy etc).\n""","""Ggs[Ȃ) . \n"""
"""""","""Specify the number of attributes to retain. The default value ""","""ۗL鑮̐w肵ĂB ftHgl"""
"""""","""(-1) indicates that all attributes are to be retained. Use either ""","""(-1) ׂĂ̑ۗL邱Ƃł邱Ƃ܂B ǂ炩gpĂB"""
"""""","""this option or a threshold to reduce the attribute set.""","""邱̃IvV~Zbg܂B"""
"""""","""Set threshold by which attributes can be discarded. Default value ""","""̂Ă邱Ƃł~ݒ肵ĂB ftHgl"""
"""""","""results in no attributes being discarded. Use either this option or ""","""̂ĂȂɂSʁB ܂͂̃IvVgpĂB"""
"""""","""numToSelect to reduce the attribute set.""","""numToSelect̓Zbg܂B"""
"""""","""A constant option. Ranker is only capable of generating ""","""̃IvVB 胉N𔭐邱Ƃł邾łB"""
"""""",""" attribute rankings.""",""" LOʂƍlĂB"""
"""""","""Specify a set of attributes to ignore. ""","""1Zbg̑w肵ĂB"""
"""""",""" When generating the ranking, Ranker will not evaluate the attributes """,""" LO𔭐ƂARanker͑]Ȃł傤B"""
"""""",""" in this list. """,""" ł́ALڂĂB"""
"""""","""This is specified as a comma ""","""̓R}ƂĎw肳܂B"""
"""""","""seperated list off attribute indexes starting at 1. It can include ""","""seperatedXg1܂B ͕܂邱Ƃł܂B"""
"""""","""ranges. Eg. 1,2,5-9,17.""","""͈́B Ⴆ 1,2,5-9,17."""
"""""","""\tSpecify a starting set of attributes.""","""\͎n߂̃Zbg̑tSpecify܂B"""
"""""","""\n\tEg. 1,3,5-7.""","""\n~̐2Nڂ̗rB 1,3,5-7."""
"""""","""\t\nAny starting attributes specified are""","""n߂̑w肵\t\nAny͂łB"""
"""""","""\t\nignored during the ranking.""","""\t\̓LO̊ԁAnignored܂B"""
"""""","""-P <start set>""","""-P<n߂̓Zbg܂>"""
"""""","""\tSpecify a theshold by which attributes""","""\͂ǂ̑thesholdtSpecify邩B"""
"""""","""\tmay be discarded from the ranking.""","""̂ĂāA\̓LOtmay܂B"""
"""""","""\tSpecify number of attributes to select""","""\͑I鑮̐tSpecify܂B"""
"""""","""-N <num to select>""","""-N<I邽߂num>"""
"""""",""" is not a""",""" ał͂܂B"""
"""""","""Attribute evaluator!""","""]!"""
"""""","""Search must be performed before a ranked ""","""aitOɌsȂ΂Ȃ܂B"""
"""""","""attribute list can be obtained""","""Xg𓾂邱Ƃł܂B"""
"""""","""More attributes requested than exist in the data""","""葽̑vAf[^ł́A݂Ă܂B"""
"""""","""\tAttribute ranking.\n""","""\tAttributeLO\n"""
"""""","""\tIgnored attributes: ""","""\͑tIgnored܂: """
"""""","""\tThreshold for discarding attributes: ""","""̂Ă邽߂\tThreshold: """
"""""","""RankSearch : \n\n""","""RankSearch: \n\n"""
"""""","""Uses an attribute/subset evaluator to rank all attributes. ""","""ׂĂ̑it̂ɑ/W]҂gp܂B"""
"""""","""If a subset evaluator is specified, then a forward selection ""","""WłȂA]҂͎w肳āAɁAtH[h͑IłB"""
"""""","""search is used to generate a ranked list. From the ranked ""","""́AitꂽXg𔭐̂Ɏgp܂B it"""
"""""","""list of attributes, subsets of increasing size are evaluated, ie. ""","""̃XgATCY̕ẂA]ĂāAiełB"""
"""""","""The best attribute, the best attribute plus the next best attribute, ""","""łǂAłǂAю̍łǂ"""
"""""","""etc.... The best attribute set is reported. RankSearch is linear in ""","""Ȃǁc łǂZbg͕񍐂܂B RankSearch͒ŒIłB"""
"""""","""the number of attributes if a simple attribute evaluator is used ""","""̐͏^ȑ]҂łȂgpĂ܂B"""
"""""","""such as GainRatioAttributeEval.\n""","""GainRatioAttributeEval\n̂悤"""
"""""","""Attribute evaluator to use for generating a ranking.""","""LO𐶐̂Ɏgp]҂ʂƍlĂB"""
"""""","""\tclass name of attribute evaluator to""","""\͑]҂̖Otclass܂B"""
"""""","""\n\tuse for ranking. Place any""","""LÔ߂\n\tuseB uĂB"""
"""""","""\n\tevaluator options LAST on the""","""\n\tevaluatorLASTɂ䂾˂܂B"""
"""""","""\n\teg. -A weka.attributeSelection.""","""\n~̐2Nڂ̗rB -weka.attributeSelectionB"""
"""""","""GainRatioAttributeEval ... ""","""GainRatioAttributeEvalc"""
"""""","""-A <attribute evaluator>""","""-A<]>"""
"""""","""An attribute evaluator  must be specified with""","""]҂ƋɎw肵Ȃ΂Ȃ܂B"""
"""""","""-A option""","""-AIvV"""
"""""",""" is not a """,""" ał͂܂B"""
"""""","""Subset evaluator!""","""W]!"""
"""""","""Can't use an attribute transformer ""","""ψgp邱Ƃł܂B"""
"""""","""with RankSearch""","""RankSearchƋ"""
"""""","""Must use an unsupervised subset evaluator.""","""ē󂯂ȂW]҂gpȂ΂Ȃ܂B"""
"""""","""\tRankSearch :\n""","""\tRankSearch: \n"""
"""""","""\tAttribute evaluator : ""","""\tAttribute]: """
"""""","""\tAttribute ranking : \n""","""\tAttributeLO: \n"""
"""""","""\tMerit of best subset found : ""","""łǂW\tMerit͌܂: """
"""""","""ReliefFAttributeEval :\n\nEvaluates the worth of an attribute by ""","""ReliefFAttributeEval: \n\nEvaluatesẢl"""
"""""","""repeatedly sampling an instance and considering the value of the ""","""JԂė𒊏oāAll܂B"""
"""""","""given attribute for the nearest instance of the same and different ""","""łĈقȂ邱Ƃ̍ł߂CX^X̂߂̗^ꂽ"""
"""""","""class. Can operate on both discrete and continuous class data.\n""","""NXB UIȂ̂ƓlɘANXf[^\n쓮邱Ƃł܂B"""
"""""","""\tSpecify the number of instances to\n""","""\\nɗ̐tSpecify܂B"""
"""""","""\tsample when estimating attributes.\n""","""ςƂA\tsample. \nʂƍl܂B"""
"""""","""\tIf not specified, then all instances\n""","""āA\tIfׂ͂Ă̗\nw肵܂łB"""
"""""","""\twill be used.""","""\DAgpĂB"""
"""""","""-M <num instances>""","""-M<num>"""
"""""","""\tSeed for randomly sampling instances.\n""","""蓖肵ɗ\n𒊏o邽߂tSeedꂽ\"""
"""""","""-D <seed>""","""-D<܂>"""
"""""","""\tNumber of nearest neighbours (k) used\n""","""ł߂אl(k)\tNumber\ngp܂B"""
"""""","""\tto estimate attribute relevances\n""","""\tto͑K\nς܂B"""
"""""","""\t(Default = 10).""","""\t(ftHg=10)B"""
"""""","""\tWeight nearest neighbours by distance\n""","""\n̗אl̍ł߂\tWeight"""
"""""","""\tSpecify sigma value (used in an exp\n""","""\VO}ltSpecifyA(exp\nł́Agp܂B"""
"""""","""\tfunction to control how quickly\n""","""ǂꂭ炢\n𐧌䂷邩\tfunction"""
"""""","""\tweights for more distant instances\n""","""艓̗\n\tweights"""
"""""","""\tdecrease. Use in conjunction with -W.\n""","""\tdecreaseB W.\ngp"""
"""""","""\tSensible value=1/5 to 1/10 of the\n""","""1/5?1/10tSensible]\=\n"""
"""""","""\tnumber of nearest neighbours.\n""","""ł߂אl\n\tnumber"""
"""""","""\t(Default = 2)""","""\t(ftHg=2)"""
"""""","""-A <num>""","""-A<num>"""
"""""","""Set influence of nearest neighbours. Used in an exp function to ""","""ł߂אl̉eݒ肵ĂB exp@\钆ẪRl"""
"""""","""control how quickly weights decrease for more distant instances. ""","""d肪A艓̗̂߂ɂǂꂭ炢}Ɍ邩𐧌䂵ĂB"""
"""""","""Use in conjunction with weightByDistance. Sensible values = 1/5 to ""","""weightByDistanceɊ֘AāAgp܂B ʂA=1/5]܂B"""
"""""","""1/10 the number of nearest neighbours.""","""1/10Ał߂אl̐B"""
"""""","""value of sigma must be > 0!""",""""""
"""""","""Number of nearest neighbours for attribute estimation.""","""ς̂߂̍ł߂אl̐B"""
"""""","""Random seed for sampling instances.""","""W{ô߂ׂ̖̎qB"""
"""""","""Number of instances to sample. Default (-1) indicates that all ""","""oCX^X̐B ftHg(-1)Aׂ"""
"""""","""instances will be used for attribute estimation.""","""CX^X͑ςɎgpł傤B"""
"""""","""Weight nearest neighbours by their distance.""","""ނ̋ɏ]āAł߂אlɏdׂ𕉂킹ĂB"""
"""""","""ReliefF feature evaluator has not been built yet\n""","""A\nReliefF]҂ɌĂĂ܂B"""
"""""","""\tReliefF Ranking Filter""","""tB^it\tReliefF"""
"""""","""\n\tInstances sampled: ""","""\n\tInstances͒o܂: """
"""""","""all\n""","""ׂĂ\n"""
"""""","""\tNumber of nearest neighbours (k): ""","""ł߂אl(k)\tNumber: """
"""""","""\tExponentially decreasing (with distance) ""","""\tExponentially() """
"""""","""influence for\n""","""\n̂߂̉e"""
"""""","""\tnearest neighbours. Sigma: ""","""\͍łtnearestɋ߂ɏZ݂܂B VO}: """
"""""","""\tEqual influence nearest neighbours\n""","""tEqualقڗאlł\nŉeyڂ\"""
"""""","""num inst:""",""""""
"""""",""" r_ndc:""",""" _r ndc:"""
"""""","""dealing""","""戵"""
"""""","""SVMAttributeEval :\n\nEvaluates the worth of an attribute by ""","""SVMAttributeEval: \n\nEvaluatesẢl"""
"""""","""using an SVM classifier.\n""","""SVMNVt@CA\ngp܂B"""
"""""","""\tSpecify the constant rate of attribute\n""","""\͑\n̈̃[gtSpecify܂B"""
"""""","""\tDefault = 1.""","""tDefault=1~B"""
"""""","""-X <constant rate of elimination>""","""-X<̈̑x>"""
"""""","""\tSpecify the percentage rate of attributes to\n""","""\͑\n̊[gtSpecify܂B"""
"""""","""\telimination per invocation of\n""","""\n̎{\telimination"""
"""""","""\tthe support vector machine.\n""","""\ttheT|[gxNg}V\n"""
"""""","""\tTrumps constant rate (above threshold).\n""","""\tTrumps̈̃[g(~𒴂)\n"""
"""""","""\tDefault = 0.""","""tDefault=0~B"""
"""""","""-Y <percent rate of elimination>""","""-Yp[Zg]肷鏜<>"""
"""""","""\tSpecify the threshold below which \n""","""\͂ǂ\n艺ŕ~tSpecify邩B"""
"""""","""\tpercentage attribute elimination\n""","""\tpercentage\n"""
"""""","""\treverts to the constant method.\n""","""\͒萔ɕ@\ntreverts܂B"""
"""""","""-Z <threshold for percent elimination>""","""-Z<p[Zĝ߂̕~>"""
"""""","""\tSpecify the value of P (epsilon\n""","""\P̒ltSpecifyA(CvV\n"""
"""""","""\tDefault = 1.0e-25""","""\tDefault=1.0e-25"""
"""""","""-P <epsilon>""","""-P<CvV>"""
"""""","""\tSpecify the value of T (tolerance\n""","""\T̒ltSpecifyA(e\n"""
"""""","""\tDefault = 1.0e-10""","""\tDefault=1.0e-10"""
"""""","""-T <tolerance>""","""-T<e>"""
"""""","""\tSpecify the value of C (complexity\n""","""\C̒ltSpecifyA(G\n"""
"""""","""\tparameter) to pass on to the\n""","""\tparameter) \nɒʂ邽߂"""
"""""","""\tsupport vector machine.\n""","""\tsupportxNg}V\n"""
"""""","""\tDefault = 1.0""","""tDefault=1.0~"""
"""""","""-C <complexity>""","""-C<G>"""
"""""","""\tWhether the SVM should ""","""tWhether SVMׂł\"""
"""""","""0=normalize/1=standardize/2=neither. ""","""0=/1𐳏ɂ܂B= = ǂ/2WȂłB"""
"""""","""Constant rate of attribute elimination.""","""̈̑xB"""
"""""","""Percent rate of attribute elimination.""","""̃p[ZgxB"""
"""""","""Threshold below which percent elimination reverts to constant elimination.""","""~͂ǂ̃p[Zg̉Ɉ̏ɖ߂邩B"""
"""""","""P epsilon parameter to pass to the SVM""","""SVMɒʉ߂PCvVp^"""
"""""","""T tolerance parameter to pass to the SVM""","""SVMɒʉ߂Tep^"""
"""""","""C complexity parameter to pass to the SVM""","""SVMɒʉ߂CGp^"""
"""""","""filtering used by the SVM""","""SVMɂĎgpꂽtB^O"""
"""""","""All nominal attributes must be binary!""","""ׂĂ̖ڏ̑2iłɈႢ܂!"""
"""""","""\tSVM feature evaluator has not been built yet""","""\tSVM]҂͂܂ĂĂ܂B"""
"""""","""\tSVM feature evaluator""","""\tSVM͕]҂W܂B"""
"""""","""GainRatioAttributeEval :\n\nEvaluates the worth of an attribute ""","""GainRatioAttributeEval: \n\nEvaluates͑̉lłB"""
"""""","""by measuring the symmetrical uncertainty with respect to the class. ""","""NXɊւđΏ̂̕sm𑪒肷邱ƂɂāB"""
"""""","""\n\n SymmU(Class, Attribute) = 2 * (H(Class) - H(Class | Attribute)) ""","""2\n\n SymmU(NXA)=*(H(NX)--H(NX| )) """
"""""","""/ H(Class) + H(Attribute).\n""","""/H(NX)+H(ʂƍl܂) \n"""
"""""","""\ttreat missing values as a seperate ""","""seperateƂĒl𓦂\ttreat"""
"""""","""value.""","""lB"""
"""""","""Distribute counts for missing values. Counts are distributed ""","""l̂߂̃JEgLĂB JEg͕zĂ܂B"""
"""""","""across other values in proportion to their frequency. Otherwise, ""","""̕pxɔႵ̒ľɁB łȂ"""
"""""","""missing is treated as a separate value.""","""蓦Ƃ͕ʁX̒lƂĈ܂B"""
"""""","""\tSymmetrical Uncertainty evaluator has not been built""","""\tSymmetrical Uncertainty]҂͌ĂĂ܂B"""
"""""","""\tSymmetrical Uncertainty Ranking Filter""","""\tSymmetricalsmLOtB^"""
"""""","""\n\tMissing values treated as seperate""","""seperateƂĈꂽltMissing\n\"""
"""""","""Evaluates attribute sets by using a learning scheme. Cross ""","""wǨngp邱ƂɂāAZbg]܂B \"""
"""""","""validation is used to estimate the accuracy of the learning ""","""@́AwK̐xς̂Ɏgp܂B"""
"""""","""scheme for a set of attributes.\n""","""1Zbg\nv悵ĂB"""
"""""","""\tclass name of base learner to use for""","""\͎gpx[XwK҂̖Otclass܂B"""
"""""","""\n\taccuracy estimation. Place any""","""n~\taccuracyςB uĂB"""
"""""","""\n\tclassifier options LAST on the""","""\n\tclassifierLASTɂ䂾˂܂B"""
"""""","""\n\tcommand line following a ""--"".""","""uu--vvɑn~\tcommandnB"""
"""""","""\n\teg. -B weka.classifiers.bayes.NaiveBayes ... ""","""\n~̐2Nڂ̗rB -B weka.classifiers.bayes.NaiveBayesc"""
"""""","""-B <base learner>""","""-B<x[XwK>"""
"""""","""\tnumber of cross validation folds to ""","""@܂dȂ\\tnumber"""
"""""","""use\n\tfor estimating accuracy.""","""xςȂA\n\tforgpĂB"""
"""""","""\n\t(default=5)""","""\n\t(ftHg=5)"""
"""""","""\tSeed for cross validation accuracy ""","""Ă鍇@x̂߂tSeedꂽ\"""
"""""","""\n\testimation.""","""\n\testimationB"""
"""""","""\n\t(default = 1)""","""\n\t(ftHg=1)"""
"""""","""\tthreshold by which to execute ""","""\́As邽߂ɂǂtthreshold邩B"""
"""""","""another cross validation""","""ʂ̌Ă鍇@"""
"""""","""\n\t(standard deviation---""","""\n\tA(KiE--"""
"""""","""expressed as a percentage of the ""","""ƂāA\܂B"""
"""""","""-T <num>""","""-T<num>"""
"""""","""\nOptions specific to""","""\nOptionsڍ"""
"""""","""scheme ""","""v"""
"""""","""A learning scheme must be specified with""","""wKvŁAw肵Ȃ΂Ȃ܂B"""
"""""","""-B option""","""-BIvV"""
"""""","""Repeat xval if stdev of mean exceeds this value.""","""stdev̒l𒴂ȂAxvalJԂĂB"""
"""""","""Number of xval folds to use when estimating subset accuracy.""","""WxςƂAxval͎̐gpɐ܂dȂ܂B"""
"""""","""Seed to use for randomly generating xval splits.""","""āAxval蓖肵ɔ̂ɌҊgpĂB"""
"""""","""Classifier to use for estimating the accuracy of subsets""","""W̐xς̂ɎgpNVt@CA"""
"""""","""\tWrapper subset evaluator has not been built yet\n""","""A\n\tWrapperW]҂ɌĂĂ܂B"""
"""""","""\tWrapper Subset Evaluator\n""","""\tWrapperW]\n"""
"""""","""\tLearning scheme: ""","""\tLearningv: """
"""""","""\tScheme options: ""","""\tSchemeIvV: """
"""""","""\tAccuracy estimation: RMSE\n""","""\tAccuracyς: RMSE\n"""
"""""","""\tAccuracy estimation: classification error\n""","""\tAccuracyς: ތ\n"""
"""""","""\tNumber of folds for accuracy estimation: ""","""xς̂߂̐܂ڂ\tNumber: """
"""""","""AODE achieves highly accurate classification by averaging over all ""","""AODÉAׂďŕς邱ƂɂāAxȕނB܂B"""
"""""","""of a small space of alternative naive-Bayes-like models that have ""","""ւ̃iC[uȃxCŶ悤Ȃf̏Xy[Xɂ"""
"""""","""weaker (and hence less detrimental) independence assumptions than ""","""キ(āAقǗLQłȂ)̓Ɨ"""
"""""","""naive Bayes. The resulting algorithm is computationally efficient while ""","""iC[uȃxCYB ʂƂċNASY͌vZIłB"""
"""""","""delivering highly accurate classification on many learning tasks.\n\n""","""̊wK^XN\n\nōxȕނ񋟂܂B"""
"""""","""G. Webb, J. Boughton & Z. Wang (2004). Not So Naive Bayes. """,""""""
"""""","""To be published in Machine Learning. """,""""""
"""""","""G. Webb, J. Boughton & Z. Wang (2002). <i>Averaged One-Dependence """,""""""
"""""","""Estimators: Preliminary Results. AI2002 Data Mining Workshop, Canberra.""",""""""
"""""","""AODE: Class is numeric!""","""AODE: NX͐lł!"""
"""""","""AODE: String attributes are not allowed.""","""AODE: XgO͋eĂ܂B"""
"""""","""Attributes must be nominal.  ""","""͖ڏłɈႢ܂B"""
"""""","""Discretize dataset with FilteredClassifer.""","""DiscretizeAFilteredClassiferf[^ZbgB"""
"""""","""\tOutput debugging information\n""","""\nfobO\tOutput"""
"""""","""\tImpose a frequency limit for superParents\n""","""\tImposesuperParents\n̂߂̕pxEłB"""
"""""","""\t(default is 30)""","""\t(ftHg30ł)"""
"""""","""The AODE Classifier""","""AODENVt@CA"""
"""""","""Dataset: ""","""f[^Zbg: """
"""""","""Instances: ""","""CX^X: """
"""""","""Attributes: """,""": """
"""""","""Frequency limit for superParents: ""","""superParentŝ߂̕pxE: """
"""""","""BayesNet: nominal class, please.""","""BayesNet: ڏ̃NX肢܂B"""
"""""","""Oef, done!""","""OefłāAɂ!"""
"""""","""BayesNet does not handle string variables, only nominal and continuous.""","""BayesNet̓m~ił̘Aϐ܂B"""
"""""","""BayesNet does not handle date variables, only nominal and continuous.""","""BayesNet̓m~ił̘At̕ϐ܂B"""
"""""","""BayesNet handles nominal variables only. Non-nominal variable in dataset detected.""","""BayesNet͖ڏ̕ϐ܂B oꂽf[^Zbg̔񖼖ڏ̕ϐB"""
"""""","""BayesNet: no missing values, please.""","""BayesNet: l͂B"""
"""""","""Warning: discretizing data set""","""x: Uf[^Zbg"""
"""""","""Warning: filling in missing values in data set""","""x: f[^ZbǧlɋL܂B"""
"""""","""Warning: Found missing value in test set, filling in values.""","""x: lɋLāAeXgEZbgɂ錇lݗĂB"""
"""""","""\tDo not use ADTree data structure\n""","""\tDoADTreef[^\\ngp܂B"""
"""""","""\tBIF file to compare with\n""","""\tBIF́A\nƔr邽߂Ƀt@C܂B"""
"""""","""-B <BIF file>""","""-B<BIF̓t@C܂>"""
"""""","""\tSearch algorithm\n""","""\tSearchASY\n"""
"""""","""-Q weka.classifiers.bayes.net.search.SearchAlgorithm""","""-Qweka.classifiers.bayes.net.search.SearchAlgorithm"""
"""""","""\tEstimator algorithm\n""","""\tEstimatorASY\n"""
"""""","""-E weka.classifiers.bayes.net.estimate.SimpleEstimator""","""-Eweka.classifiers.bayes.net.estimate.SimpleEstimator"""
"""""","""A searchAlgorithmName must be specified with""","""searchAlgorithmNameƋɎw肵Ȃ΂Ȃ܂B"""
"""""",""" the -Q option.""",""" -QIvVB"""
"""""","""A estimatorName must be specified with""","""estimatorNameƋɎw肵Ȃ΂Ȃ܂B"""
"""""",""" the -E option.""",""" -EIvVB"""
"""""","""Bayes Network Classifier""","""xCYlbg[NNVt@CA"""
"""""","""not using ""","""gpȂ"""
"""""","""ADTree""",""""""
"""""","""\n#attributes=""","""\n#="""
"""""",""" #classindex=""",""""""
"""""","""\nNetwork structure (nodes followed by parents)\n""","""\nNetwork\n\܂(eɂď]ꂽm[h)B"""
"""""","""LogScore Bayes: ""","""LogScorexCY: """
"""""","""LogScore BDeu: """,""""""
"""""","""LogScore MDL: """,""""""
"""""","""LogScore ENTROPY: ""","""LogScoreGgs[: """
"""""","""LogScore AIC: ""","""LogScoreACN: """
"""""","""Missing: ""","""蓦܂: """
"""""",""" Extra: """,""" GLXg: """
"""""",""" Reversed: """,""" tɂ: """
"""""","""Divergence: """,""": """
"""""","""<!--No model built yet-->""","""<--ǂȃf܂ĂĂ܂ł-->"""
"""""","""	<!ELEMENT NETWORK ( NAME, ( PROPERTY | VARIABLE | DEFINITION )* )>\n""","""	<!vflbg[N((OA(|ϐ|`)*>)\n"""
"""""","""	<!ELEMENT VARIABLE ( NAME, ( OUTCOME |  PROPERTY )* ) >\n""","""	<!vfς((OA(| )*>)\n"""
"""""","""	      <!ATTLIST VARIABLE TYPE (nature|decision|utility) ""nature"">\n""","""	<!ATTLIST̉σ^Cv(R||[eBeB)uuRvv>\n"""
"""""","""	<!ELEMENT DEFINITION ( FOR | GIVEN | TABLE | PROPERTY )* >\n""","""	<!vf`((| R̂|e[u|) *̂߂>)\n"""
"""""","""<OUTCOME>""","""<>"""
"""""","""<GIVEN>""","""<^܂>"""
"""""","""When ADTree (the data structure for increasing speed on counts,""","""ADTreełA(JEĝƂɉ邽߂̃f[^\"""
"""""",""" not to be confused with the classifier under the same name) is used""",""" ỎɂNVt@CAɍȂA)AgpĂ܂B"""
"""""",""" learning time goes down typically. However, because ADTrees are memory""",""" wKԂ͒ʏ헎܂B ȂAADTrees̓łB"""
"""""",""" intensive, memory problems may occur. Switching this option off makes""",""" OIȃ͋N邩܂B ł̃IvV؂芷܂B"""
"""""",""" the structure learning algorithms slower, and run with less memory.""",""" 菭ȂŁAxASYwŁAꂽ\B"""
"""""",""" By default, ADTrees are used.""",""" ftHgŁAADTrees͎gpĂ܂B"""
"""""","""Select method used for searching network structures.""","""Tlbg[N\Ɏgp郁\bhIĂB"""
"""""","""Select Estimator algorithm for finding the conditional probability tables""","""tme[u邽߂EstimatorASYIĂB"""
"""""","""Set the name of a file in BIF XML format. A Bayes network learned""","""BIF XML`Ńt@C̖Oݒ肵ĂB xCYlbg[N͊wт܂B"""
"""""",""" from data can be compared with the Bayes network represented by the BIF file.""",""" f[^ABIFt@Cɂđ\xCYlbg[NƔr邱Ƃł܂B"""
"""""",""" Statistics calculated are o.a. the number of missing and extra arcs.""",""" vZꂽvo.łBa. Ăė]ȃA[N̐B"""
"""""","""Bayes Network learning using various search algorithms and quality measures.""","""lXȌASYƕigp邱ƂŊwԃxCYNetwork肵܂B"""
"""""","""measureExtraArcs""",""""""
"""""","""measureMissingArcs""",""""""
"""""","""measureReversedArcs""",""""""
"""""","""measureDivergence""",""""""
"""""","""measureBayesScore""",""""""
"""""","""measureBDeuScore""",""""""
"""""","""measureMDLScore""",""""""
"""""","""measureAICScore""",""""""
"""""","""measureEntropyScore""",""""""
"""""","""\tNormalize the word weights for each class\n""","""\͂ꂼ̃NX\nPʂ̒PdtNormalize܂B"""
"""""","""\tSmoothing value to avoid zero WordGivenClass""","""[WordGivenClass邽߂ɒltSmoothing\"""
"""""",""" probabilities (default=1.0).\n""",""" m(ftHg=1.0)\n"""
"""""","""Normalizes the word weights for each class.""","""eNX̂߂ɒPd𐳏ɂ܂B"""
"""""","""Sets the smoothing parameter to avoid zero WordGivenClass ""","""X[WOp^Ƀ[WordGivenClass悤ɐݒ肵܂B"""
"""""","""probabilities (default=1.0).""","""m(ftHg=1.0)B"""
"""""","""Class for building and using a Complement class Naive Bayes ""","""Complement𑢂āAgp邽߂̃NXNaivexCY𕪗ނ܂B"""
"""""","""classifier. For more information see, \n""","""NVt@CAB 񂪌ȏA\n"""
"""""","""ICML-2003 ""Tackling the poor assumptions of Naive Bayes """,""""""
"""""","""Text Classifiers"" \n""",""""""
"""""","""P.S.: TF, IDF and length normalization transforms, as ""","""ǐL: 퉻ςTFAIDFAђ"""
"""""","""described in the paper, can be performed through ""","""ŐĂāAs邱Ƃł܂B"""
"""""","""ComplementNaiveBayes cannot ""","""ComplementNaiveBayes͂邱Ƃł܂B"""
"""""","""handle non-nominal class attribute""","""񖼖ڏ̃NXĂB"""
"""""",""" is not numeric! """,""" lłȂ!"""
"""""","""ComplementNaiveBayes requires ""","""ComplementNaiveBayesKvłB"""
"""""","""that all attributes (except the ""","""ꂪׂČʂƍlA("""
"""""","""class attribute) are numeric.""","""NX) l͂ł?"""
"""""","""Numeric attribute""","""l"""
"""""",""" values must all be greater""",""" lׂ͂đ傫Ȃ΂Ȃ܂B"""
"""""",""" or equal to zero.""",""" ܂́A[ɍ킹邽߂ɁAłB"""
"""""","""Error. The classifier has not been built ""","""B NVt@CA͑gĂĂ܂B"""
"""""","""properly.""","""K؂ɁB"""
"""""","""The classifier hasn't been built yet.""","""NVt@CA͂܂gĂĂ܂B"""
"""""","""The word weights for each class are: \n""","""eNX̂߂̒Pd͈ȉ̒ʂłB \n"""
"""""","""Class for a Naive Bayes classifier using estimator classes. Numeric""","""ςlgpĂNaivexCYNVt@CÂ߂̃NX͑܂B l"""
"""""",""" estimator precision values are chosen based on analysis of the """,""" ςlxl͕͂ɊÂđI΂Ă܂B"""
"""""",""" training data. For this reason, the classifier is not an""",""" f[^P܂B NVt@CA̗͂Rłł"""
"""""",""" UpdateableClassifier (which in typical usage are initialized with zero""",""" UpdateableClassifierA(T^Iȗp@ŁA[ŏ܂B"""
"""""",""" training instances) -- if you need the UpdateableClassifier functionality,""",""" g[jO) -- ȂUpdateableClassifier̋@\KvƂȂ"""
"""""",""" use the NaiveBayesUpdateable classifier. The NaiveBayesUpdateable""",""" NaiveBayesUpdateableNVt@CAgpĂB NaiveBayesUpdateable"""
"""""",""" classifier will  use a default precision of 0.1 for numeric attributes""",""" NVt@CA͐l0.1̏ȗ̐xgpł傤B"""
"""""",""" when buildClassifier is called with zero training instances.\n\n""",""" buildClassifier[g[jO\n\nŌĂ΂Ƃ"""
"""""","""George H. John and Pat Langley (1995). Estimating""",""""""
"""""",""" Continuous Distributions in Bayesian Classifiers. Proceedings""",""""""
"""""",""" of the Eleventh Conference on Uncertainty in Artificial""",""""""
"""""",""" Intelligence. pp. 338-345. Morgan Kaufmann, San Mateo.""",""""""
"""""","""Attribute type unknown to NaiveBayes""","""NaiveBayesɂAm̑^Cv"""
"""""","""NaN returned from estimator for attribute ""","""NaN͑̂߂Ɍςl߂܂B"""
"""""","""\tUse kernel density estimator rather than normal\n""","""\nނ\tUseJ[lxςl"""
"""""","""\tdistribution for numeric attributes""","""l̂߂\tdistribution"""
"""""","""\tUse supervised discretization to process numeric attributes\n""","""\tUséAl\n邽߂ɗUē܂B"""
"""""","""Can't use both kernel density ""","""gp邱ƂłȂAJ[lx"""
"""""","""estimation and discretization!""","""ςƗU!"""
"""""","""Naive Bayes Classifier""","""iC[uȃxCYNVt@CA"""
"""""",""": Prior probability = """,""": Om="""
"""""","""Use a kernel estimator for numeric attributes rather than a ""","""aނ됔lɃJ[lςlgpĂB"""
"""""","""normal distribution.""","""KzB"""
"""""","""Use supervised discretization to convert numeric attributes to nominal ""","""gṕAl𖼖ڏɕϊ邽߂ɗUē܂B"""
"""""","""ones.""","""́B"""
"""""","""Class for building and using a multinomial Naive Bayes classifier. ""","""NaivexCYNVt@CAgĂāAgp邽߂̃NXB"""
"""""","""For more information see,\n\n""","""񂪌ȏA\n\n"""
"""""","""Andrew Mccallum, Kamal Nigam (1998) A Comparison of Event Models for Naive ""","""Ah[MccallumAo̔rfJ}jK(1998)AiC[u"""
"""""","""Bayes Text Classification""","""xCYeLXg"""
"""""","""The class attribute is required to be nominal. This is currently not the case!""","""NXAڏɂȂ̂ɕKvłB ݁A͂ł͂܂!"""
"""""",""" is not numeric! NaiveBayesMultinomial1 requires that all attributes (except the class attribute) are numeric.""",""" lłȂ! NaiveBayesMultinomial1́AׂĂ̑(NX)lł邱ƂKvƂ܂B"""
"""""","""Numeric attribute values must all be greater or equal to zero.""","""lĺA[ɍ킹邽߂ɂׂĂ傫A܂͓Ȃ΂Ȃ܂B"""
"""""","""The independent probability of a class\n--------------------------------------\n""","""NX\n̓ƗĂm--------------------------------------\n"""
"""""","""\nThe probability of a word given the class\n-----------------------------------------\n\t""","""NX\n^ꂽP\nThem-----------------------------------------\n\t"""
"""""","""Class for building and using a simple Naive Bayes classifier.""","""^NaivexCYNVt@CAgĂāAgp邽߂̃NXB"""
"""""","""Numeric attributes are modelled by a normal distribution. For more ""","""l͐Kzɂăf܂B ȏ"""
"""""","""Richard Duda and Peter Hart (1973). Pattern """,""""""
"""""","""Classification and Scene Analysis. Wiley, New York.""",""""""
"""""","""Naive Bayes: Class is numeric!""","""iC[uȃxCY: NX͐lł!"""
"""""",""": less than two values for class """,""": NX̂߂2̒l"""
"""""","""attribute """,""""""
"""""",""": standard deviation is 0 for class """,""": W΍̓NX̂߂0łB"""
"""""","""Naive Bayes (simple): No model built yet.""","""iC[uȃxCY(ȒP): ǂȃf܂ĂĂ܂łB"""
"""""","""Naive Bayes (simple)""","""iC[uȃxCY(ȒP)łB"""
"""""","""Attribute """,""""""
"""""","""Standard Deviation: ""","""W΍: """
"""""","""Can't print Naive Bayes classifier!""","""NaivexCYNVt@CA邱Ƃł܂!"""
"""""","""Class for a Naive Bayes classifier using estimator classes. This is the ""","""ςlgpĂNaivexCYNVt@CÂ߂̃NX͑܂B ͂łB"""
"""""","""updateable version of NaiveBayes.""","""NaiveBayes̃Abvf[g\o[WB"""
"""""","""This classifier will use a default precision of 0.1 for numeric attributes ""","""̃NVt@CA͐l0.1̏ȗ̐xgpł傤B"""
"""""","""when buildClassifier is called with zero training instances.\n\n""","""buildClassifier[g[jO\n\nŌĂ΂Ƃ"""
"""""","""For more information on Naive Bayes classifiers, see\n\n""","""NaivexCYNVt@CȀڂɊւẮA\n\nĂB"""
"""""","""George H. John and Pat Langley (1995). Estimating """,""""""
"""""","""Continuous Distributions in Bayesian Classifiers. Proceedings """,""""""
"""""","""of the Eleventh Conference on Uncertainty in Artificial """,""""""
"""""","""Intelligence. pp. 338-345. Morgan Kaufmann, San Mateo.\n\n""",""""""
"""""","""Can't use discretization ""","""Ugp邱Ƃł܂B"""
"""""","""in NaiveBayesUpdateable!""","""NaiveBayesUpdateable!"""
"""""","""Count = ""","""JEg="""
"""""","""Node""","""m[h"""
"""""","""RandomNet""",""""""
"""""","""Number of arcs should be at least (nNodes - 1) = ""","""A[N̐͏ȂƂ(nNodes--1)=łׂłB"""
"""""","""Number of arcs should be at most nNodes * (nNodes - 1) / 2 = ""","""A[N͍̐XnNodes*(nNodes--1)/2=łׂłB"""
"""""",""" instead of """,""" instead of"""
"""""","""\tGenerate network (instead of instances)\n""","""\tGenerate\nlbg[NłȂ܂(CX^X̑)B"""
"""""","""\tNr of nodes\n""","""m[h\n\tNr"""
"""""","""-N <integer>""","""-N<>"""
"""""","""\tNr of arcs\n""","""A[N\n\tNr"""
"""""","""\tNr of instances\n""","""\n\tNr"""
"""""","""-M <integer>""","""-M<>"""
"""""","""\tCardinality of the variables\n""","""ϐ\n\tCardinality"""
"""""","""\tSeed for random number generator\n""","""\ntSeedꂽ\"""
"""""","""-S <integer>""","""-S<>"""
"""""","""\tThe BIF file to obtain the structure from.\n""","""\tThe BIF. \n\肷邽߂Ƀt@C܂B"""
"""""","""-F <file>""","""-F<t@C܂>"""
"""""","""Options for ""","""IvV"""
"""""","""No definition found for node ""","""ǂȒ`m[h̗LȔ܂łB"""
"""""","""More than one definition found for node ""","""1ȏ̒`m[h̗LȔ܂B"""
"""""",""". Using first definition.""",""".. ŏ̒`gp܂B"""
"""""","""Cannot synchronize networks: different number of attributes.""","""lbg[N𓯊邱Ƃł܂: قȂ̑B"""
"""""","""Could not find node [[""","""m[h͌邱Ƃł܂łB"""
"""""","""No name specified for variable""","""ϐɎw肳ȂOS"""
"""""","""position = (73, 165)""","""ʒu=(73, 165)"""
"""""","""Wrong number format in position :(""","""ʒůԈ̏:A("""
"""""","""Could not find definition for ((""","""`邱ƂłȂA("""
"""""","""Incorrect BayesNetEstimator: use subclass instead.""","""smBayesNetEstimator: ɃTuNXgpĂB"""
"""""","""\tInitial count (alpha)\n""","""\tInitial\n𐔂܂(At@)B"""
"""""","""-A <alpha>""","""-A<At@>"""
"""""","""Alpha is used for estimating the probability tables and can be interpreted""","""At@[me[uς̂ɎgpāA߂邱Ƃł܂B"""
"""""",""" as the initial count on each value.""",""" elɂ鏉̃JEgƂāB"""
"""""","""An Estimator is an algorithm for finding the conditional probability tables""","""EstimatoŕAtme[u邽߂̃ASYłB"""
"""""",""" of the Bayes Network.""",""" xCYlbg[NɂāB"""
"""""","""Cannot handle networks with nodes with more than 1 parent (yet).""","""1lȏ̐eƋɃm[hŃlbg[N(܂)Ƃł܂B"""
"""""","""updateClassifier does not apply to BMA estimator""","""updateClassifierBMAςlɓKp܂B"""
"""""","""\tWhether to use K2 prior.\n""","""P[c[DIɎgp\tWhetherA\n"""
"""""","""\tWhen determining whether an edge exists a search is performed ""","""݂Ă邩ۂɊ֌WȂAŝ肷\tWhen"""
"""""","""\tfor a set Z that separates the nodes. MaxCardinality determines ""","""\tfora̓m[h؂藣Zݒ肵܂B MaxCardinality͌肵܂B"""
"""""","""\tthe maximum size of the set Z. This greatly influences the ""","""ZbgZ.ThisttheőTCY傢ɉeyڂ\"""
"""""","""\tlength of the search. (default  2)""","""\tlengthB (ftHg2)"""
"""""","""-cardinality <num>""","""-<num>"""
"""""","""cardinality""",""""""
"""""","""-cardinality""","""-"""
"""""","""When determining whether an edge exists a search is performed for a set Z ""","""݂邩ǂ肷ƂA̓ZbgẐ߂Ɏs܂B"""
"""""","""that separates the nodes. MaxCardinality determines the maximum size of the set Z. ""","""̓m[h؂藣܂B MaxCardinality̓ZbgZ̍őTCY𑪒肵܂B"""
"""""","""This greatly influences the length of the search. Default value is 2.""","""͌̒ɑ傢ɉeyڂ܂B ftHgl2łB"""
"""""","""This Bayes Network learning algorithm uses conditional independence tests ""","""̃xCYNetworkwKASY͏t̓ƗeXggp܂B"""
"""""","""to find a skeleton, finds V-nodes and applies a set of rules to find the directions ""","""[āAV-m[hāAw邽߂1Zbg̋KKp܂B"""
"""""","""of the remaining arrows.""","""cĂɂāB"""
"""""","""Could not find attribute ""","""Ȃ܂B"""
"""""",""" from BIF file in data""",""" f[^BIFt@C"""
"""""","""\tName of file containing network structure in BIF format\n""","""BIF`\nɃlbg[N\܂ރt@C\tName"""
"""""","""-B <BIF File>""","""-B<BIF̓t@C܂>"""
"""""","""Unrecognized cross validation type encountered: ""","""^CvFĂȂĂ鍇@: """
"""""","""\tScore type (LOO-CV,k-Fold-CV,Cumulative-CV)\n""","""\tScore(LOO-CVAk܂ڂCVACumulative-CV)\n^Cv܂B"""
"""""","""-S [LOO-CV|k-Fold-CV|Cumulative-CV]""","""-S֏-CV| k{CV| ݐςĂCV"""
"""""","""\tUse probabilistic or 0/1 scoring.\n\t(default probabilistic scoring)""","""mIł邩0/1\tUseȓ_\n\t(ftHg̊mIȓ_)"""
"""""","""LOO-CV""","""֏-CV"""
"""""","""k-Fold-CV""","""k{CV"""
"""""","""Cumulative-CV""","""ݐςĂCV"""
"""""","""Select cross validation strategy to be used in searching for networks.""","""Ă鍇@헪lbg[N{߂ۂɎgp̂IĂB"""
"""""","""LOO-CV = Leave one out cross validation\n""","""LOO-CV=͌Ă鍇@\nȂ܂B"""
"""""","""k-Fold-CV = k fold cross validation\n""","""k܂ڂ̏\@k܂ڂCV=\n"""
"""""","""Cumulative-CV = cumulative cross validation.""","""ݐςĂĂݐςĂCV=@B"""
"""""","""If set to true, the probability of the class if returned in the estimate of the ""","""{ւ̃ZbgANX̊młAςł́A߂܂B"""
"""""","""accuracy. If set to false, the accuracy estimate is only increased if the classifier returns ""","""xB Ă̂ɐݒ肳ȂANVt@CA߂ꍇɂAxς͑܂B"""
"""""","""exactly the correct class.""","""܂ɐNXB"""
"""""","""This Bayes Network learning algorithm uses cross validation to estimate ""","""ASYprς邽߂ɍ@Ɍ̂wԂ̃xCYNetwork"""
"""""","""classification accuracy.""","""ސxB"""
"""""","""Descendant PopulationSize should be at least Population Size""","""qPopulationSize͏ȂƂPopulation SizełׂłB"""
"""""","""At least one of mutation or cross-over should be used""","""ȂƂ1AψقfgpׂłB"""
"""""","""\tPopulation size\n""","""\tPopulationTCY\n"""
"""""","""\tDescendant population size\n""","""\tDescendantlTCY\n"""
"""""","""-A <integer>""","""-A<>"""
"""""","""\tUse mutation.\n\t(default true)""","""\tUseψ\n\t({ɁAftHgƂ܂)"""
"""""","""\tUse cross-over.\n\t(default true)""","""\tUsef\n\t({ɁAftHgƂ܂)"""
"""""","""\tUse tournament selection (true) or maximum subpopulatin (false).\n\t(default false)""","""\tUseg[igI({)ősubpopulatin()\n\t(UŃftHgƂ܂)"""
"""""","""This Bayes Network learning algorithm uses genetic search for finding a well scoring ""","""̃xCYNetworkwKASÝA˂؂菝Ă̂킩̂Ɉ`q̌gp܂B"""
"""""","""Bayes network structure. Genetic search works by having a population of Bayes network structures ""","""xCYlbg[N\B xCYlbg[N\̐lĂ̂ɂ`q̌i"""
"""""","""and allow them to mutate and apply cross over to get offspring. The best network structure ""","""āAނɎq𓾂邽߂ɏIĂ\ψقāAKpĂB łǂlbg[N\"""
"""""","""found during the process is returned.""","""ݗAvZX̊ԁAԂ܂B"""
"""""","""Sets the number of generations of Bayes network structure populations.""","""̃xCYlbg[N\l̐ݒ肵܂B"""
"""""","""Sets the size of the population of network structures that is selected each generation.""","""ePʂőIlbg[N\̐l̃TCỸZbgB"""
"""""","""Sets the size of the population of descendants that is created each generation.""","""ePʂō쐬q̐l̃TCỸZbgB"""
"""""","""Determines whether mutation is allowed. Mutation flips a bit in the bit ""","""ψقeĂ邩ۂɊ֌WȂA肵܂B ψق̓rbgŏԂ肵܂B"""
"""""","""representation of the network structure. At least one of mutation or cross-over ""","""lbg[N\̕\B ȂƂ1Aψقf"""
"""""","""Determines whether cross-over is allowed. Cross over combined the bit ""","""feĂ邩ۂɊ֌WȂA肵܂B ŃrbgɌĂB"""
"""""","""representations of network structure by taking a random first k bits of one""","""1ׂ̖̍ŏk̃rbĝɂlbg[N\̕\"""
"""""","""and adding the remainder of the other. At least one of mutation or cross-over ""","""āAЕ̎c邱ƁB ȂƂ1Aψقf"""
"""""","""should be used.""","""gpׂłB"""
"""""","""Determines the method of selecting a population. When set to true, tournament ""","""lI郁\bh肵܂B {ɐݒ肳ꂽAg[ig"""
"""""","""selection is used (pick two at random and the highest is allowed to continue). ""","""I͎gpĂ܂(ׂ2IłB΁Ał̂͑Ƃł܂)B"""
"""""","""When set to false, the top scoring network structures are selected.""","""Ă̂ɐݒ肳ƁAō_lbg[N\͑I܂B"""
"""""","""Add ""","""ĂB"""
"""""","""Del ""","""Del"""
"""""","""Rev ""","""]"""
"""""","""This Bayes Network learning algorithm uses a hill climbing algorithm ""","""̃xCYNetworkwKASY͋u̓oĂASYgp܂B"""
"""""","""adding, deleting and reversing arcs. The search is not restricted by an order ""","""A[NāA폜āAtɂ܂B ̓I[_[Ő܂B"""
"""""","""on the variables (unlike K2). The difference with B and B2 is that this hill ""","""ϐ(P[c[ƈقȂ)ɊւāB BB2ႢłA̋u"""
"""""","""climber also considers arrows part of the naive Bayes structure for deletion.""","""폜̂߂̃iC[uȃxCY\̈ꕔŎ܂܂AoRƂAlB"""
"""""","""When set to true, the arc reversal operation is used in the search.""","""{ɐݒ肳ƁAA[N]͌Ɏgp܂B"""
"""""","""\tInitial structure is empty (instead of Naive Bayes)\n""","""tInitial\\͋(NaivexCY̑)\nłB"""
"""""","""\tRandom order.\n""","""\tRandomI[_[\n"""
"""""","""This Bayes Network learning algorithm uses a hill climbing algorithm""","""̃xCYNetworkwKASY͋u̓oĂASYgp܂B"""
"""""",""" restricted by an order on the variables""",""" ϐɊւI[_[ŁA܂B"""
"""""","""When set to true, the order of the nodes in the network is random.""","""{ɐݒ肳ƁAlbg[NɂAm[hׂ͖̒łB"""
"""""",""" Default random order is false and the order""",""" ftHgׂ̖̃I[_[́AĂĒłB"""
"""""",""" of the nodes in the dataset is used.""",""" gpf[^Zbg̃m[hɂāB"""
"""""",""" In any case, when the network was initialized as Naive Bayes Network, the""",""" lbg[NNaivexCYNetworkƂďꂽƂ̂ǂȏꍇł"""
"""""",""" class variable is first in the ordering though.""",""" ƂAŏɁAɂ̓NXϐ܂B"""
"""""","""\tApplies a Markov Blanket correction to the network structure, ""","""\̓lbg[N\Ƀ}RtBlanketCtApplies܂B"""
"""""","""\tafter a network structure is learned. This ensures that all ""","""\tafteralbg[N\͊w΂܂B ꂪmɂAׂ"""
"""""","""\tnodes in the network are part of the Markov blanket of the ""","""lbg[Nɂ\tnodes̓}Rtѕz̈ꕔłB"""
"""""","""\tclassifier node.\n""","""\tclassifierm[h\n"""
"""""","""\tScore type (BAYES, BDeu, MDL, ENTROPY and AIC)\n""","""\tScore\n^Cv܂(xCYABDeuAMDLAENTROPYAуACN)B"""
"""""","""-S [BAYES|MDL|ENTROPY|AIC|CROSS_CLASSIC|CROSS_BAYES]""","""-SxCY|MDL|Ggs[| ACN| _NVbNɌĂ| _xCYɌ܂B"""
"""""","""mbc""",""""""
"""""","""-mbc""",""""""
"""""","""BAYES""","""xCY"""
"""""","""BDeu""",""""""
"""""","""MDL""",""""""
"""""","""ENTROPY""","""Ggs["""
"""""","""The score type determines the measure used to judge the quality of a""","""XRA^Cv́A肪ȑO͂悭a̕i𔻒fĂƌSĂ܂B"""
"""""",""" network structure. It can be one of Bayes, BDeu, Minimum Description Length (MDL),""",""" lbg[N\B ̓xCŶЂƂABDeuAMinimum Description Lengthł邩܂(MDL)B"""
"""""",""" Akaike Information Criterion (AIC), and Entropy.""",""" ԒrʋK(ACN)AуGgs[B"""
"""""","""-A <seed>""","""-A<܂>"""
"""""","""This Bayes Network learning algorithm repeatedly uses hill climbing starting ""","""̃xCYNetworkwKASY͌JԂċu̓oĂn߂gp܂B"""
"""""","""with a randomly generated network structure and return the best structure of the ""","""aŎ蓖肵Ƀlbg[N\𐶐āAłǂ\Ԃ܂B"""
"""""","""various runs.""","""lXȑsB"""
"""""","""Sets the number of times hill climbing is performed.""","""ũNC~OsƂ̐ݒ肵܂B"""
"""""","""Try delete ""","""gC͍폜܂B"""
"""""","""Try add ""","""gC͉܂B"""
"""""",""" dScore = """,""" dScore="""
"""""","""success!!!""","""!"""
"""""","""\tStart temperature\n""","""\tStartx\n"""
"""""","""-A <float>""","""-A<ׂ܂>"""
"""""","""\tDelta temperature\n""","""\tDeltax\n"""
"""""","""-D <float>""","""-D<ׂ܂>"""
"""""","""\tRandom number seed\n""","""\tRandom̎q\n"""
"""""","""This Bayes Network learning algorithm uses the general purpose search method ""","""̃xCYNetworkwKASY͔ėp̌\bhgp܂B"""
"""""","""of simulated annealing to find a well scoring network structure.""","""˓_lbg[N\V~[gꂽAj[OɂāB"""
"""""","""Sets the start temperature of the simulated annealing search. ""","""V~[gꂽAj[ÕX^[gx̃Zbg͒T܂B"""
"""""","""The start temperature determines the probability that a step in the 'wrong' direction in the ""","""X^[gxaɒ'ԈĂ'ɓ܂Ƃm𑪒肵܂B"""
"""""","""search space is accepted. The higher the temperature, the higher the probability of acceptance.""","""Xy[X󂯓܂B x΍قǁAiḿA荂łB"""
"""""","""Sets the number of iterations to be performed by the simulated annealing search.""","""JԂ̐ɃV~[gꂽAj[OŎs悤ɐݒ肵܂B"""
"""""","""Sets the factor with which the temperature (and thus the acceptance probability of ""","""vfݒ肷AǂAxA(̌ʁAFm"""
"""""","""steps in the wrong direction in the search space) is decreased in each iteration.""","""Xy[X̊ԈwɊÂXebv) eJԂł́A܂B"""
"""""","""Initialization value for random number generator.""","""̂߂̏ݒlB"""
"""""",""" Setting the seed allows replicability of experiments.""",""" qݒ肷ƁAreplicability͋e܂B"""
"""""","""Panic: could not find any step to make. Tabu list too long?""","""pjbN: ǂȃXebv邱Ƃł܂łB ^uE͂܂ɒԁALڂ܂?"""
"""""","""\tTabu list length\n""","""\tTabu͒\nLڂ܂B"""
"""""","""-L <integer>""","""-L<>"""
"""""","""\tNumber of runs\n""","""s\n\tNumber"""
"""""","""-U <integer>""","""-U<>"""
"""""","""\tMaximum number of parents\n""","""e\n\tMaximumԍ"""
"""""","""-P <nr of parents>""","""-P<enr>"""
"""""","""\tUse arc reversal operation.\n\t(default false)""","""\tUseA[N]\n\t(UŃftHgƂ܂)"""
"""""","""This Bayes Network learning algorithm uses tabu search for finding a well scoring ""","""̃xCYNetworkwKASÝA˂؂菝Ă̂킩̂ɋ֊gp܂B"""
"""""","""Bayes network structure. Tabu search is hill climbing till an optimum is reached. The ""","""xCYlbg[N\B œKɒB܂ŁA^uE͋ũNC~OłB The"""
"""""","""following step is the least worst possible step. The last X steps are kept in a list and ""","""̃Xebv͍łȂ\ȃXebvłB čŌXXebvXg̒ɕۂB"""
"""""","""none of the steps in this so called tabu list is considered in taking the next step. ""","""̂֊XgɂXebv̂̎iۂɍl܂B"""
"""""","""The best network found in this traversal is returned.""","""̏cfŌ钆ōłǂlbg[NԂ܂B"""
"""""","""Sets the number of steps to be performed.""","""Xebv̐Ɏs悤ɐݒ肵܂B"""
"""""","""Sets the length of the tabu list.""","""֊̒̃Zbg͋Lڂ܂B"""
"""""","""Bug condition found: too many arrows""","""oOԂ͌܂: ܂ɑ̖"""
"""""","""This Bayes Network learning algorithm determines the maximum weight spanning tree ""","""̃xCYNetworkwKASY͍ő吧dʃXpjOc[肵܂B"""
"""""",""" and returns a Naive Bayes network augmented with a tree.""",""" āANaivexCYlbg[N؂ő傳^[B"""
"""""","""SearchAlgorithm\n""",""""""
"""""","""Set the maximum number of parents a node in the Bayes net can have.""","""xCYlbgɂm[hƂł闼e̍ő吔ݒ肵ĂB"""
"""""",""" When initialized as Naive Bayes, setting this parameter to 1 results in""",""" NaivexCYƂďĂāA1ɂ̃p^ݒ肷̂͂ʂƂĐ܂B"""
"""""",""" a Naive Bayes classifier. When set to 2, a Tree Augmented Bayes Network (TAN)""",""" NaivexCYNVt@CAB 2ATree AugmentedxCYNetworkɃZbgȂƂꍇ(ɏĂ܂)"""
"""""",""" is learned, and when set >2, a Bayes Net Augmented Bayes Network (BAN)""",""" wpIłāAݒ肳ꂽ>2AxCYlbgAugmentedxCYNetworkł邩B(֎~܂)"""
"""""",""" is learned. By setting it to a value much larger than the number of nodes""",""" w΂܂B m[h̐͂邩ɑ傫lɂݒ肷邱Ƃɂ"""
"""""",""" in the network (the default of 100000 pretty much guarantees this), no""",""" Ńlbg[N(100000̃ftHg͂قƂǕۏ؂)A"""
"""""",""" restriction on the number of parents is enforced""",""" e̐ɂ鐧͗s܂B"""
"""""","""When set to true (default), the initial network used for structure learning""","""{ɐݒ肳(ftHg)Ãlbg[N͍\ɊwKgp܂B"""
"""""",""" is a Naive Bayes Network, that is, a network with an arrow from the classifier""",""" NaivexCYNetworkAȂ킿Albg[NNVt@CA̖ł܂B"""
"""""",""" node to each other node. When set to false, an empty network is used as initial""",""" m[hA݂Ƀm[hB Ă̂ɐݒ肳ƁÃlbg[N͓炢Ŏgp܂B"""
"""""",""" network structure""",""" lbg[N\"""
"""""","""When set to true (default is false), after a network structure is learned""","""lbg[N\w΂ꂽɖ{(ftHg͌Ă)ɃZbgȂƂꍇ"""
"""""",""" a Markov Blanket correction is applied to the network structure. This ensures""",""" }RtBlanketC̓lbg[N\ɓKp܂B ͊mɂ܂B"""
"""""",""" that all nodes in the network are part of the Markov blanket of the classifier""",""" lbg[Nɂ邷ׂẴm[hNVt@CÃ}Rtѕz̈ꕔłB"""
"""""",""" node.""",""" m[h"""
"""""","""MCV""",""""""
"""""","""\tThe number of instances placed in the training pool.\n""","""g[jOɒuꂽ\tTheԍ. \nv[܂B"""
"""""","""\tThe remainder will be used for testing. (default 100)""","""\tThećAeXĝɎgpł傤B (ftHg100)"""
"""""","""-T <training pool size>""","""-T<g[jOv[ETCY>"""
"""""","""\tThe number of training repetitions used.\n""","""g[jO\tTheԍ. \ngp܂B"""
"""""","""\t(default 50)""","""\t(ftHg50)"""
"""""","""-x <num>""","""-x <num>"""
"""""","""The dataset must contain at least ""","""ȂƂK{܂ރf[^Zbg"""
"""""","""Iteration ""","""JԂ"""
"""""","""\nBias-Variance Decomposition\n""","""ω̕nBiasĂ\\n"""
"""""","""\nClassifier   : ""","""\nClassifier: """
"""""","""\nData File    : ""","""\nData̓t@C܂: """
"""""","""\nClass Index  : ""","""\nClass͍܂: """
"""""","""\nTraining Pool: ""","""\nTrainingv[: """
"""""","""\nIterations   : ""","""\nIterations: """
"""""","""\nSeed         : ""","""\nSeed܂: """
"""""","""\nError        : ""","""\nError: """
"""""","""\nSigma^2      : ""","""nSigma^2~: """
"""""","""\nBias^2       : ""","""nBias^2~: """
"""""","""\nVariance     : ""","""\nVariance: """
"""""","""\tThe index of the class attribute.\n""","""tTheNX\. \nʂƍl܂B"""
"""""","""\t(default last)""","""\t(ŌɃftHgƂ܂)"""
"""""","""-c <class index>""","""-c<NXCfbNX>"""
"""""","""\tThe number of times each instance is classified.\n""","""ꂼ̃CX^XނĂƂ\tTheԍA\n"""
"""""","""-l <num>""","""-l<num>"""
"""""","""\tThe average proportion of instances common between any two training sets\n""","""\tThe̓Zbg\nPǂ2̊ԂłʓIȃCX^X̊𕽋ς܂B"""
"""""","""-p <proportion of objects in common>""","""-p <ʓI̊̕>"""
"""""","""\tThe random number seed used.""","""\tgꂽ_̎"""
"""""","""-s <seed>""","""-s <̎>"""
"""""","""\tThe name of the arff file used for the decomposition.""","""tThe镪Ɏgparfft@C\B"""
"""""","""-t <name of arff file>""","""-t <arfft@C̖O>"""
"""""","""\tThe number of instances in the training set.""","""g[jOɂACX^X\tTheԍ̓Zbg܂B"""
"""""","""-T <number of instances in training set>""","""-T<g[jOɂA̐̓Zbg܂>"""
"""""","""\tFull class name of the learner used in the decomposition.\n""","""\tFullNXwKҖ͕. \ngp܂B"""
"""""","""-W <classifier class name>""","""-W <ރNX>"""
"""""","""\nOptions specific to learner ""","""wK҂ɂƂāA\nOptions"""
"""""","""A proportion must be specified""","""w肵Ȃ΂Ȃ܂B"""
"""""",""" with a -p option.""",""" -p IvVŁB"""
"""""","""An arff file must be specified""","""arfft@Cw肵Ȃ΂Ȃ܂B"""
"""""",""" with the -t option.""",""" -t IvVŁB"""
"""""","""A training set size must be specified""","""g[jOZbgTCYw肵Ȃ΂Ȃ܂B"""
"""""",""" with a -T option.""",""" -T IvVŁB"""
"""""","""A learner must be specified with the -W option.""","""-WIvVŊwK҂w肵Ȃ΂Ȃ܂B"""
"""""","""Class attribute must be nominal""","""NX͖ڏłɈႢ܂B"""
"""""","""Dataset size must be greater than 2.""","""f[^ZbgTCY2ȏłɈႢ܂B"""
"""""","""Training set size of ""","""Pf[^Zbg̃TCY"""
"""""",""" is invalid.""",""" sK؂ł"""
"""""","""Proportion is not in range: ""","""͈͂ɂ܂: """
"""""",""" <= p < 1.0 """,""" <= p <1.0"""
"""""","""The required number of folds is too many.""","""܂ڂ̕Kv͑߂܂B"""
"""""","""Change p or the size of the training set.""","""g[jO̕ωpTCYZbg܂B"""
"""""","""The training set size of ""","""g[jO̓TCYݒ肵܂B"""
"""""",""", is greater than the training pool """,""", g[jOv[肷΂炵łB"""
"""""","""Central tendency was null.""","""̌X̓kłB"""
"""""","""Decomposition finished""","""͏I܂B"""
"""""","""\nBias-Variance Decomposition Segmentation, Cross Validation\n""","""\ω̕𕪊nBiasĂāAĂ鍇@\n"""
"""""","""with subsampling.\n""","""u-W{ov\n"""
"""""","""Invalid setup""","""ȃZbgAbv"""
"""""","""\nClassifier    : ""","""\nފ: """
"""""","""\nData File     : ""","""\nf[^t@C: """
"""""","""\nClass Index   : ""","""\nNXԍ: """
"""""","""\nIterations    : ""","""\nJԂ: """
"""""","""\nTraining Size : ""","""\nPf[^ZbgTCY: """
"""""","""\nSeed          : ""","""\n_̎: """
"""""","""Kohavi and Wolpert""","""KohaviWolpert"""
"""""","""\nBias^2        :""","""nBias^2~:"""
"""""","""\nSigma^2       :""","""nSigma^2~:"""
"""""","""\n\nDefinition   : ""","""\n\nDefinition: """
"""""","""Webb""","""EFu"""
"""""","""\nError         :""","""\nError:"""
"""""","""\nBias          :""","""\nBias:"""
"""""","""\nVariance      :""","""\nVariance:"""
"""""","""\nBVDecompose Options:\n\n""","""\nBVDecomposeIvV: \n\n"""
"""""","""\tSilent mode - prints nothing to stdout.""","""\tSilent[h--stdoutɉ܂B"""
"""""","""\tThe number of instances in the datasets (default 20).""","""f[^Zbg(ftHg20)̃CX^X\tTheԍB"""
"""""","""\tFull name of the classifier analysed.\n""","""tFullNVt@CA\. \n𕪐͂܂B"""
"""""","""\n=== No classifier set ===""","""\n=== ǂȃNVt@CAZbg܂łB==="""
"""""","""\n=== Check on Classifier: ""","""\n=== NVt@CAɂČĂ: """
"""""","""options...""","""IvVc"""
"""""","""\n=== Full report ===""","""\n=== ςɁA񍐂ĂB==="""
"""""","""updateable classifier...""","""Abvf[g\NVt@CAc"""
"""""","""weighted instances classifier...""","""̃NVt@CAɏdׂ𕉂킹܂c"""
"""""","""basic predict""","""b͗\܂B"""
"""""","""more than two class problems""","""2ȏ̃NX"""
"""""","""number""",""""""
"""""","""handle zero training instances""","""[g[jOĂB"""
"""""","""correct initialisation during buildClassifier""","""buildClassifier̊Ԃ̐"""
"""""","""Results differ between buildClassifier calls""","""ʂbuildClassifierĂяo̊ԂňقȂ܂B"""
"""""","""\n=== Full report ===\n""","""\n=== ςɁA񍐂ĂB===\n"""
"""""","""\nFirst buildClassifier()""",""""""
"""""","""\nSecond buildClassifier()""",""""""
"""""",""" of dataset 1""",""" f[^Zbg1ɂ"""
"""""",""" of dataset 2""",""" f[^Zbg2ɂ"""
"""""",""" of dataset 1 (2nd build)""",""" f[^Zbg1ɂ(2ԖڂɁAĂ܂)"""
"""""",""", comparing results from builds of dataset 1""",""", f[^Zbg1̑̊i猋ʂr܂B"""
"""""","""=== Train1 Dataset ===\n""","""=== Train1f[^Zbg===\n"""
"""""","""=== Test1 Dataset ===\n""","""=== Test1f[^Zbg===\n"""
"""""","""=== Train2 Dataset ===\n""","""=== Train2f[^Zbg===\n"""
"""""","""=== Test2 Dataset ===\n""","""=== Test2f[^Zbg===\n"""
"""""","""100% """,""""""
"""""",""" predictor""",""" \"""
"""""",""" and""",""" """
"""""",""" values""",""" l"""
"""""","""train""",""""""
"""""","""incremental training produces the same results""","""̃g[jO͓ʂ𐶂݂܂B"""
"""""",""" as batch training""",""" ob`g[jOƂ"""
"""""","""Results differ between batch and ""","""Čʂob`̊ԂňقȂB"""
"""""","""incrementally built models.\n""","""f\n͑ČĂ܂B"""
"""""","""Depending on the classifier, this may be OK""","""NVt@CAɗĂāAOKł邩܂B"""
"""""","""\nbatch built results\n""","""\nĂꂽ\nbatch"""
"""""","""\nincrementally built results\n""","""\nnincrementallyɌĂꂽ\"""
"""""","""classifier ignores test instance class vals""","""NVt@CA̓eXgCX^X̃NXvals𖳎܂B"""
"""""","""Prediction different for instance ""","""Ⴆ΁AقȂ\"""
"""""","""Results differ between non-missing and ""","""ČʂԂɔ񌇂ĂԂňقȂB"""
"""""","""missing test class values.""","""eXgKl𓦂܂B"""
"""""","""Problem during testing""","""eXg̊Ԃ̖"""
"""""","""classifier uses instance weights""","""NVt@CA̓CX^Xdgp܂B"""
"""""","""evalFail""",""""""
"""""","""Results don't differ between non-weighted and ""","""ČʂԂɔ׏dĂԂňقȂȂB"""
"""""","""weighted instance models.""","""׏dĂCX^X̓f܂B"""
"""""","""Here are the results:\n""","""ɁA: \n܂B"""
"""""","""\nboth methods\n""","""\nboth@\n"""
"""""","""=== Train Weights ===\n""","""=== ԏd===\n"""
"""""","""(test weights all 1.0\n""","""(eXgׂ͂Ă1.0~nɏd݂܂B"""
"""""","""classifier doesn't alter original datasets""","""NVt@CA̓IWĩf[^ZbgύX܂B"""
"""""","""Here are the datasets:\n""","""ɁAf[^Zbg: \n܂B"""
"""""","""Error setting up for tests: ""","""eXgɂāAɂȂĂݒ: """
"""""","""Scheme performs worse than ZeroR""","""vZeroRЂǂ܂B"""
"""""","""worse than zeror""","""zeror舫łB"""
"""""","""warning: performs worse than ZeroR""","""x: ZeroRЂǂA܂B"""
"""""",""" (OK error message)""",""" (OKG[bZ[W)"""
"""""","""\n=== Full Report ===""","""\n=== ςɁA񍐂ĂB==="""
"""""","""Problem during""",""""""
"""""",""" testing""",""" eXg"""
"""""",""" training""",""" g[jO"""
"""""","""Error message doesn't mention ""","""G[bZ[W͌y܂B"""
"""""","""here are the datasets:\n""","""ɁAf[^Zbg: \n܂B"""
"""""","""=== Train Dataset ===\n""","""=== ԃf[^Zbg===\n"""
"""""","""=== Test Dataset ===\n""","""=== eXgf[^Zbg===\n"""
"""""","""Problem determining ZeroR performance: ""","""ZeroR\肷邱Ƃɂ: """
"""""","""header has been modified""","""wb_[͕ύX܂B"""
"""""","""number of instances has changed""","""CX^X͕̐ω܂B"""
"""""","""instances have changed""","""CX^X͕ω܂B"""
"""""","""instance weights have changed""","""CX^Xd͕ω܂B"""
"""""","""The""",""""""
"""""","""quick""","""v"""
"""""","""fox""","""Lcl"""
"""""","""jumps""","""Wv"""
"""""","""dog""",""""""
"""""","""CheckSet""",""""""
"""""",""" numeric""",""" l^"""
"""""",""" nominal""",""" `^"""
"""""",""" string""",""" ^"""
"""""",""" predictors)""",""" \l)"""
"""""",""" (numeric class,""",""" (lNX"""
"""""",""" (nominal class,""",""" (`NX"""
"""""","""\nCheckClassifier Options:\n\n""","""\nCheckClassifierIvV: \n\n"""
"""""","""No model classifier set""","""ǂȃfNVt@CAZbg܂łB"""
"""""","""\tIf set, classifier is run in debug mode and\n""","""\tIf̓ZbgāANVt@CA̓fobO[h\nɗ₷邱ƂłB"""
"""""","""\tmay output additional info to the console""","""\tmay̓R\[ɒǉCtH[Vo͂܂B"""
"""""","""If set to true, classifier may output additional info to ""","""trueɐݒ肳ƁCފwKASY͒ǉCtH[V"""
"""""","""the console.""","""R\[ɏo͂܂D"""
"""""","""Trying to create a non-square cost matrix""","""񐳕`p}gNX쐬悤Ƃ܂B"""
"""""","""Class index is not set!""","""NXCfbNX͐ݒ肳܂!"""
"""""","""Misclassification cost matrix has ""","""p}gNXɂ͂镪ތ"""
"""""","""wrong format!""","""Ԉ`!"""
"""""","""Neg. weights in misclassification ""","""Negތɂd"""
"""""","""cost matrix!""","""}gNXĂ!"""
"""""","""Length of probability estimates don't match cost matrix""","""ς肪p}gNXɍȂƂm̒"""
"""""","""First number in line has to be ""","""ŏɁAtԂ̂߂ɐĂRlɕtԂ܂B"""
"""""","""Second number in line has to be ""","""b͕tԂ̂߂ɐĂRlɕtԂ܂B"""
"""""","""index of a class!""","""NXɍĂ!"""
"""""","""Class index out of range!""","""NX͔͈͂܂!"""
"""""","""Diagonal of cost matrix non-zero!""","""p}gNXΊp̔["""
"""""","""Premature end of file!""","""ȃt@C̏I!"""
"""""","""Premature end of line!""","""ȍs!"""
"""""","""Only numbers and comments allowed ""","""ƋeꂽRg"""
"""""","""in cost file!""","""pł́At@CĂ!"""
"""""","""Only positive weights allowed!""","""eꂽz̏d肾!"""
"""""","""Cost and confusion matrices must be the same size""","""pƍ}gNX͓TCYłɈႢ܂B"""
"""""","""No predicted value given.""","""͗^ꂽl\܂B"""
"""""","""No actual value given.""","""͗^܂łB"""
"""""","""     actual class\n""",""" ۂ̃NX\n"""
"""""","""CostCurve""",""""""
"""""","""Probability Cost Function""","""mp@\"""
"""""","""Normalized Expected Cost""","""ɂꂽҌ"""
"""""","""Margin""","""}[W"""
"""""","""Current""","""d"""
"""""","""Cumulative""","""ݐ"""
"""""","""MarginCurve""",""""""
"""""","""Null distribution in NominalPrediction.""","""NominalPredictionł̃kzB"""
"""""","""NOM: """,""""""
"""""","""NUM: """,""""""
"""""","""ThresholdCurve""",""""""
"""""","""True Positives""",""""""
"""""","""False Negatives""",""""""
"""""","""False Positives""",""""""
"""""","""True Negatives""",""""""
"""""","""False Positive Rate""",""""""
"""""","""True Positive Rate""",""""""
"""""","""Precision""","""\"""
"""""","""Recall""","""Č"""
"""""","""Fallout""",""""""
"""""","""FMeasure""",""""""
"""""","""Threshold""","""臒l"""
"""""",""" Skipping prediction with missing class value""",""" ĂKlŗ\T{܂B"""
"""""",""" Skipping prediction with negative weight""",""" ̏dŗ\T{܂B"""
"""""","""Point ""","""|Cg"""
"""""","""Point2 ""","""Point2"""
"""""",""" area'=""",""" '̈'="""
"""""","""negative""","""ےI"""
"""""","""Class has to be nominal if cost matrix ""","""NX͔p}gNXłȂ疼ڏłȂ΂Ȃ܂B"""
"""""","""given!""","""^!"""
"""""","""Cost matrix not compatible with data!""","""f[^Ƃ̃Rp`ułȂ}gNXĂ!"""
"""""","""The first argument must be the class name""","""ŏ̋c_̓NXłɈႢ܂B"""
"""""",""" of a classifier""",""" NVt@CAɂ"""
"""""","""Graphable.""","""GraphablełB"""
"""""","""No training file and no test ""","""g[jOt@CȂĂ܂eXg܂B"""
"""""","""file given.""","""^ԂŁAt@CĂB"""
"""""","""Classifier not incremental, or no ""","""NVt@CAAłȂAB"""
"""""","""test file provided: can't ""","""eXgt@C͒񋟂܂: can't"""
"""""","""use both train and model file.""","""Ԃƃft@C̗gpĂB"""
"""""","""Train and test file not compatible!""","""Rp`ułȂt@CPāAĂ!"""
"""""","""Index of class attribute too large.""","""NXɑ傫߂ԂōĂB"""
"""""","""No actual dataset provided to use as template""","""f[^Zbg̓ev[gƂĎgpɒ񋟂܂łہB"""
"""""","""\nWeka exception: ""","""\nWekaO: """
"""""","""\n=== Evaluation Cost Matrix ===\n\n""","""\n=== ]p}gNX===\n\n"""
"""""","""\nTime taken to test model on training data: ""","""eXg邽߂Ɏꂽ\nTime̓g[jOf[^܂: """
"""""",""" seconds""",""" b"""
"""""","""\n\n=== Error on training""","""\n\n=== g[jǑ"""
"""""",""" data ===\n""",""" f[^===\n"""
"""""","""=== Error on test data ===\n""","""=== eXgf[^ɂ===\n"""
"""""","""\n\n\n""","""\An~n\n"""
"""""","""=== Stratified ""","""=== wɂ܂B"""
"""""","""cross-validation ===\n""","""Ă鍇@===\n"""
"""""","""NOTE: The behaviour of the -m option has changed between WEKA 3.0""",""": -mIvV̂ӂ܂WEKA3.0̊Ԃŕω܂B"""
"""""",""" and WEKA 3.1. -m now carries out cost-sensitive *evaluation*""",""" āAWeka 3.1B -m͌݁Apqȕ]s܂B"""
"""""",""" only. For cost-sensitive *prediction*, use one of the""",""" PɁB p@*\*̂߂ɁA1gpĂB"""
"""""",""" cost-sensitive metaschemes such as""",""" pqmetaschemes"""
"""""",""" weka.classifiers.meta.CostSensitiveClassifier or""",""" ܂weka.classifiers.meta.CostSensitiveClassifierB"""
"""""",""" weka.classifiers.meta.MetaCost""",""""""
"""""","""Attempting to read old format cost file""","""Âpt@Cǂނ݂̂܂B"""
"""""","""Created default cost matrix""","""쐬ꂽsRXg}gNX"""
"""""","""Read old format""","""ÂǂłB"""
"""""","""Re-throwing original exception""","""Ĉ꓊̗̌O"""
"""""","""StaticClassifier""",""""""
"""""","""package weka.classifiers;\n""","""pbP[Wweka.classifiers; \n"""
"""""","""import weka.core.Attribute;\n""","""Aweka.core.Attribute; \n"""
"""""","""import weka.core.Instance;\n""","""Aweka.core.Instance; \n"""
"""""","""import weka.core.Instances;\n""","""Aweka.core.Instances; \n"""
"""""","""import weka.classifiers.Classifier;\n\n""","""Aweka.classifiers.Classifier; \n\n"""
"""""","""public class WekaWrapper extends Classifier {\n\n""","""̃NXWekaWrapperClassifier{\n\nLĂ܂B"""
"""""","""  public void buildClassifier(Instances i) throws Exception {\n""",""" ̋buildClassifier(i)Exception{\n𓊂܂B"""
"""""","""  public double classifyInstance(Instance i) throws Exception {\n\n""",""" ̓dclassifyInstance(i)Exception{\n\n𓊂܂B"""
"""""","""    Object [] s = new Object [i.numAttributes()];\n""",""" IuWFNgAVs=ObjectAi.numAttributes(); \n"""
"""""","""    for (int j = 0; j < s.length; j++) {\n""",""" (int j=0; j<s.̒; j++){\n"""
"""""","""      if (!i.isMissing(j)) {\n""",""" (i.isMissing(j)){\n"""
"""""","""        if (i.attribute(j).type() == Attribute.NOMINAL) {\n""",""" (i.(j).type()==Attribute.NOMINAL){\nłB"""
"""""","""          s[j] = i.attribute(j).value((int) i.value(j));\n""",""" i.(j).value(int)i.s j=l(j)); \n"""
"""""","""        } else if (i.attribute(j).type() == Attribute.NUMERIC) {\n""",""" } قA(i.(j).type()==Attribute.NUMERIC){\nłB"""
"""""","""          s[j] = new Double(i.value(j));\n""",""" Vs j=DoubleA(i.l(j)); \n"""
"""""","""Can't compute correlation coefficient: ""","""֌WvZ邱Ƃł܂: """
"""""","""class is nominal!""","""NX͖ڏł!"""
"""""","""Can't compute entropy of class prior: ""","""NX̃Ggs[DIɌvZ邱Ƃł܂: """
"""""","""Can't compute K&B Info score: ""","""KvZ邱ƂłȂŁAB Info͓_܂: """
"""""","""class numeric!""","""NXl!"""
"""""","""Class must be nominal for margin distributions""","""}[WzɂāANX͖ڏłɈႢ܂B"""
"""""","""=== Summary ===\n""","""=== Tv ===\n"""
"""""","""Correctly Classified Instances     ""","""ނꂽf[^"""
"""""","""Incorrectly Classified Instances   ""","""ĕނꂽf[^"""
"""""","""Kappa statistic                    ""","""Kappavl"""
"""""","""Total Cost                         ""","""vRXg"""
"""""","""Average Cost                       ""","""σRXg"""
"""""","""K&B Relative Info Score            ""","""K&Bݏ"""
"""""","""K&B Information Score              ""","""K&B"""
"""""","""Correlation coefficient            ""","""֌W"""
"""""","""Class complexity | order 0         ""","""NX̕G | I[_[0"""
"""""","""Class complexity | scheme          ""","""NX̕G | XL["""
"""""","""Complexity improvement     (Sf)    ""","""G(Sf) """
"""""",""" bits""",""" rbg"""
"""""",""" bits/instance\n""",""" rbg/f[^\n"""
"""""","""Mean absolute error                ""","""ϐΌ덷"""
"""""","""Root mean squared error            ""","""ϕ덷"""
"""""","""Relative absolute error            ""","""ΓIȐΌ덷"""
"""""","""Root relative squared error        ""","""Γ덷"""
"""""","""UnClassified Instances             ""","""ނȂf[^"""
"""""","""Total Number of Instances          ""","""f[^̑"""
"""""","""Ignored Class Unknown Instances            ""","""ꂽNXm̃f[^"""
"""""","""Arggh - Must be a bug in Evaluation class""","""Arggh--EvaluatioñNXɂoOłȂ΂Ȃ܂B"""
"""""","""=== Confusion Matrix ===\n""","""=== }gNX ===\n"""
"""""","""   <-- classified as\n""",""" <--\\n"""
"""""","""=== Detailed Accuracy By Class ===\n""","""=== NXɂڍׂȐ ===\n"""
"""""","""Evaluation: No confusion matrix possible!""","""]: \ȍ}gNX܂!"""
"""""","""\nTP Rate   FP Rate""","""\nTP[g   FP[g"""
"""""","""   Precision   Recall""","""  \   Č"""
"""""","""  F-Measure   Class\n""","""  F-Measure   NX\n"""
"""""",""" missing """,""" """
"""""","""missing """,""""""
"""""","""\tSets test file. If missing, a cross-validation""","""\tSets̓t@C܂B 蓦Ă鍇@łB"""
"""""",""" will be performed on the training data.\n""",""" g[jOf[^ɎsA\n"""
"""""","""\tSets index of class attribute (default: last).\n""","""tSetsNX(ftHg: ŏI)\n\"""
"""""","""\tSets number of folds for cross-validation (default: 10).\n""","""Ă鍇@(ftHg: 10)\n̐܂ڂ\tSetsԍ"""
"""""","""\tSets random number seed for cross-validation (default: 1).\n""","""Ă鍇@(ftHg: 1)\n̂߂\tSetsq"""
"""""","""-m <name of file with cost matrix>\n""","""-m<p}gNXt@C̖O>\n"""
"""""","""\tSets file with cost matrix.\n""","""\tSets͔p}gNX\nŃt@C܂B"""
"""""","""\tOutputs no statistics for training data.\n""","""\tOutputs̓g[jOf[^\n̓vł͂܂B"""
"""""","""\tOutputs statistics only, not the classifier.\n""",""".. \͓vtOutputsāÃNVt@CA\nł͂܂B"""
"""""","""\tOutputs detailed information-retrieval""","""\tOutputs͏񌟍ڂqׂ܂B"""
"""""",""" statistics for each class.\n""",""" ꂼ̂߂̓v. \n𕪗ނ܂B"""
"""""","""\tOutputs information-theoretic statistics.\n""","""\tOutputs̏񗝘_Iȓv\n"""
"""""","""\tOnly outputs predictions for test instances, along with attributes ""","""\tOnlyɑɔeXgCX^X̂߂̗\o͂܂B"""
"""""","""(0 for none).\n""","""(Ȃɂ̂߂0). \n"""
"""""","""\tOnly outputs cumulative margin distribution.\n""","""\tOnlyɗݐςĂ}[Wz\no͂܂B"""
"""""","""-z <class name>\n""","""-z<NX>\n"""
"""""","""\tOnly outputs the source representation""","""\tOnlyɃ\[X\o͂܂B"""
"""""",""" of the classifier, giving it the supplied""",""" ɗ^NVt@CAɂ"""
"""""",""" name.\n""",""" O\n"""
"""""","""\tOnly outputs the graph representation""","""\tOnlyɃOt\o͂܂B"""
"""""",""" of the classifier.\n""",""" NVt@CA\n"""
"""""","""Implements a least median sqaured linear regression utilising the ""","""łłȂsqauredIȕAps܂B"""
"""""","""existing weka LinearRegression class to form predictions. ""","""\`Weka LinearRegressioñNXB"""
"""""","""Least squared regression functions are generated from random subsamples of ""","""ł悳ȂA֐ׂ͖́u-Tvv甭܂B"""
"""""","""the data. The least squared regression with the lowest meadian squared error ""","""f[^B łႢmeadianƂ̍ł悳ȂA͌悵܂B"""
"""""","""is chosen as the final model.\n\n""",""". \n\nfƂAI΂Ă܂B"""
"""""","""The basis of the algorithm is \n\nRobust regression and outlier detection ""","""ASY̊b́An~\nRobustAƃAEgCA[ołB"""
"""""","""Peter J. Rousseeuw, Annick M. Leroy. c1987""","""Annick M.s[^[J.RousseeuwAc1987"""
"""""","""m_samplesize: ""","""m_samplesize܂: """
"""""","""m_samples: ""","""m_Tv: """
"""""","""m_randomseed: ""","""m_randomseed܂: """
"""""","""model has not been built""","""f͑Ă܂B"""
"""""","""rls regression unbuilt""","""rlsAunbuilt"""
"""""","""Set the size of the random samples used to generate the least sqaured ""","""וW{̃TCYȑO͂悭łŏɔĂZbgsqaured܂B"""
"""""","""regression functions.""","""A֐B"""
"""""","""Set the seed for selecting random subsamples of the training data.""","""g[jOf[^ׂ̖́u-TvvI邽߂̎qݒ肵ĂB"""
"""""","""\tSet sample size\n""","""\tSet̓TCY\n𒊏o܂B"""
"""""","""\t(default: 4)\n""","""\t(ftHg: 4)\n"""
"""""","""-S <sample size>""","""-S<TvTCY>"""
"""""","""\tSet the seed used to generate samples\n""","""\tSet̓Tv\n𔭐̂ɎgpqłB"""
"""""","""\t(default: 0)\n""","""\t(ftHg: 0)\n"""
"""""","""-G <seed>""","""-G<܂>"""
"""""","""\tProduce debugging output\n""","""o\nfobO\tProduce"""
"""""","""\t(default no debugging output)\n""","""\t(o͂fobOȂftHg)\n"""
"""""","""r must be less that or equal to n.""","""r͈ȉn̂ꂩyłȂ炻Ȃ΂Ȃ܂B"""
"""""",""" num: """,""""""
"""""",""" denom: """,""""""
"""""","""No attribute selection""","""I܂B"""
"""""","""M5 method""","""M5\bh"""
"""""","""Greedy method""","""×~ȃ\bh"""
"""""","""Class for using linear regression for prediction. Uses the Akaike ""","""\ɒIȕAgp邽߂̃NXB Ԓrgp܂B"""
"""""","""criterion for model selection, and is able to deal with weighted ""","""]AIfāAɂłA׏dĂB"""
"""""","""instances.""","""CX^XB"""
"""""","""Linear Regression: No model built yet.""","""IȕA: ǂȃf܂ĂĂ܂łB"""
"""""","""\nLinear Regression Model\n\n""","""\nLinearAf\n\n"""
"""""","""Can't print Linear Regression!""","""Linear Regression邱Ƃł܂!"""
"""""","""\tSet the attribute selection method""","""\tSet͑I\bhłB"""
"""""",""" to use. 1 = None, 2 = Greedy.\n""",""" gp邽߂ɁB 1=ȂɂA2=A×~ł. \n"""
"""""","""\t(default 0 = M5' method)""","""\t'(M5'ftHg0=\bh)"""
"""""","""-S <number of selection method>""","""-S<I@̐>"""
"""""","""\tDo not try to eliminate colinear""","""\tDocolinearr悤Ƃ܂B"""
"""""",""" attributes.\n""",""" \n"""
"""""","""\tSet ridge parameter (default 1.0e-8).\n""","""\tSetp^(ftHg1.0e-8)\n"""
"""""","""-R <double>""","""-R<d>"""
"""""","""The value of the Ridge parameter.""","""Ridgep^̒lB"""
"""""","""Eliminate colinear attributes.""","""colinearrĂB"""
"""""","""Set the method used to select attributes for use in the linear ""","""Ił̎gp̂߂ɑÎɎgp郁\bhݒ肵ĂB"""
"""""","""regression. Available methods are: no attribute selection, attribute ""","""AB p\ȃ\bh͈ȉ̒ʂłB IȂA"""
"""""","""selection using M5's method (step through the attributes removing the one ""","""M5̃\bhgpIA(̂菜ȂAʂēłB"""
"""""","""with the smallest standardised coefficient until no improvement is observed ""","""ł̂WĂԂŁAǂȂ܂ł̌W͊ϑ܂B"""
"""""","""in the estimate of the error given by the Akaike ""","""Ԓrɂė^ꂽ̌ς"""
"""""","""information criterion), and a greedy selection using the Akaike information ""","""ʋK)AԒrgp×~ȑI"""
"""""","""metric.""","""[g@B"""
"""""","""Outputs debug information to the console.""","""o͂̓R\[ɏfobO܂B"""
"""""","""Deselected colinear attribute:""","""Deselected colinear:"""
"""""",""" with standardised coefficient: """,""" WꂽW: """
"""""","""Initial Akaike value: ""","""ԒrlɓĂ: """
"""""","""(akaike: ""","""(akaike:"""
"""""","""Removing attribute ""","""菜܂B"""
"""""",""" improved Akaike: """,""" Ԓrǂ܂: """
"""""","""doRegression(""","""doRegressionA("""
"""""","""squeeze""",""""""
"""""","""Class for building and using a multinomial logistic ""","""aĂāAgp邽߂ɑł邱ƂőĂAWXeBNX"""
"""""","""regression model with a ridge estimator.\n\n""","""ςl\n\nAf"""
"""""","""There are some modifications, however, compared to the paper of ""","""ȂAƔׂāA̕ύX܂B"""
"""""","""leCessie and van Houwelingen(1992): \n\n""",""""""
"""""","""If there are k classes for n instances with m attributes, the ""","""mn̂߂k̃NX"""
"""""","""parameter matrix B to be calculated will be an m*(k-1) matrix.\n\n""","""}gNXm*(k-1)\n\nłłȂvZׂłp^}gNXB"""
"""""","""The probability for class j with the exception of the last class is\n\n""","""Ō̃NXȊÕNXĵ߂̊m\n\nłB"""
"""""","""Pj(Xi) = exp(XiBj)/((sum[j=1..(k-1)]exp(Xi*Bj))+1) \n\n""","""n(exp(Xi*Bj)+1j=1(k-1)܂Ƃ߂܂)\exp(XiBj)/~Pj(Xi)=n"""
"""""","""The last class has probability\n\n""","""Ō̃NXɂ́Am\n\n܂B"""
"""""","""1-(sum[j=1..(k-1)]Pj(Xi)) \n\t= 1/((sum[j=1..(k-1)]exp(Xi*Bj))+1)\n\n""","""1A(n~nj=1(k-1)1/(exp(Xi*Bj)+1j=1(k-1)܂Ƃ߂)Pj(Xi)\n\t=~܂Ƃ߂ĂB"""
"""""","""The (negative) multinomial log-likelihood is thus: \n\n""","""̌ʁA(ےI)̑̃O݂͈ȉ̒ʂłB \n\n"""
"""""","""L = -sum[i=1..n]{\n\tsum[j=1..(k-1)](Yij * ln(Pj(Xi)))""","""{\n\tsum鍇vL=i=1..nAj=1(k-1)(Yij*ln(Pj(Xi)))"""
"""""","""\n\t+(1 - (sum[j=1..(k-1)]Yij)) \n\t* ln(1 - sum[j=1..(k-1)]Pj(Xi))""","""\An~t+A(1--A(j=1(k-1)܂Ƃ߂ĂAYij) \n\t*ln(1--j=1(k-1)܂Ƃ߂ĂAPj(Xi)"""
"""""","""\n\t} + ridge * (B^2)\n\n""","""\n\t} + *(B^2)\n\n"""
"""""","""In order to find the matrix B for which L is minimised, a ""","""LŏƂȂ}gNXBAa܂B"""
"""""","""Quasi-Newton Method is used to search for the optimized values of ""","""œKꂽlT̂ɂďj[gMethod͎gpĂ܂B"""
"""""","""the m*(k-1) variables.  Note that before we use the optimization ""","""m*(k-1)ϐB œKgpOɂɒӂĂB"""
"""""","""procedure, we 'squeeze' the matrix B into a m*(k-1) vector.  For ""","""菇Am*(k-1)xNgɃ}gNXB'i܂'B for"""
"""""","""details of the optimization procedure, please check ""","""ڍׂłAœK菇ł́A`FbNĂB"""
"""""","""weka.core.Optimization class.\n\n""","""weka.core.OptimizatioñNX\n\n"""
"""""","""Although original Logistic Regression does not deal with instance ""","""IWiLogistic Regression̓CX^XɑΏ܂"""
"""""","""weights, we modify the algorithm a little bit to handle the ""","""dłA̓ASYق̏nhɕύX܂B"""
"""""","""instance weights.\n\n""","""CX^Xd\n\n"""
"""""","""For more information see:\n\nle Cessie, S. and van Houwelingen, J.C. (1992). ""","""ڂɊւẮAĂ: \n\le Cessie, S. and van Houwelingen, J.C. (1992)."""
"""""","""Ridge Estimators in Logistic Regression.  Applied Statistics, """,""""""
"""""","""Vol. 41, No. 1, pp. 191-201. \n\n""",""""""
"""""","""Note: Missing values are replaced using a ReplaceMissingValuesFilter, and """,""": ReplaceMissingValuesFiltergp邱ƂŌlւB"""
"""""","""nominal attributes are transformed into numeric attributes using a ""","""ڏ̑́Aagp邱ƂŐlɕς܂B"""
"""""","""NominalToBinaryFilter.""","""NominalToBinaryFilterB"""
"""""","""\tTurn on debugging output.""","""fobOo͂ł\tTurnB"""
"""""","""\tSet the ridge in the log-likelihood.""","""\̓O݂ɂtSet܂B"""
"""""","""\tSet the maximum number of iterations""","""\tSet͌JԂ̍ő吔łB"""
"""""","""Set the Ridge value in the log-likelihood.""","""O݂Ridgel͂ߍłB"""
"""""","""Maximum number of iterations to perform.""","""ső吔̌JԂB"""
"""""","""No train instances without missing class value!""","""ĂKlȂΗԃCX^X܂!"""
"""""","""Extracting data...""","""f[^𔲐܂c"""
"""""","""Sum of weights of instances less than 1, please reweight!""","""肢܂Au-d݂v1̏d̍vA!"""
"""""","""Descriptives...""","""Descriptivesc"""
"""""",""" cases have class """,""" P[X͕i܂B"""
"""""","""\n Variable     Avg       SD    ""","""\nςAvgTEX_R^"""
"""""","""\nIteration History...""","""\nIterationjc"""
"""""","""200 iterations finished, not enough!""","""\ł͂ȂAI200JԂ!"""
"""""",""" -------------<Converged>--------------""",""" -------------<_ɏW߂܂>--------------"""
"""""","""Logistic Regression with ridge parameter of ""","""p^郍WXeBNXRegression"""
"""""","""\nCoefficients...\n""","""\nCoefficientsc\n"""
"""""","""Variable      Coeff.\n""","""Coeff\n"""
"""""","""Intercept ""","""C^Zvg"""
"""""","""\nOdds Ratios...\n""","""\nOddsc\n"""
"""""","""Variable         O.R.\n""","""O.R.\n"""
"""""","""Controls""","""Rg["""
"""""","""Num Of Epochs  ""","""̃k"""
"""""","""Epoch  """,""""""
"""""","""Error per Epoch = ""","""=̌"""
"""""","""Validation Error per Epoch = ""","""=̍@"""
"""""","""Learning Rate = ""","""wK="""
"""""","""Momentum = ""","""="""
"""""","""Accept""","""󂯓ĂB"""
"""""","""No training instances.""","""g[jOႪ܂B"""
"""""","""All class values missing.""","""ׂẴNX蓦Ƃ]܂B"""
"""""",""" The Neural Network""",""" j[Elbg[N"""
"""""","""Accept Neural Network""","""j[Elbg[N󂯓ĂB"""
"""""","""Neural Network""","""j[Elbg[N"""
"""""","""Network cannot train. Try restarting with a""","""lbg[N͌P邱Ƃł܂B aōĊJĂ݂ĂB"""
"""""",""" smaller learning rate.""",""" 킸ȊwKB"""
"""""","""\tLearning Rate for the backpropagation algorithm.\n""","""obNvpQ[VASŶ߂\tLearning RateA\n"""
"""""","""\t(Value should be between 0 - 1, Default = 0.3).""","""\t(0--1ADefault=0.3̊Ԃɂ́Alׂł)B"""
"""""","""-L <learning rate>""","""-L<wK>"""
"""""","""\tMomentum Rate for the backpropagation algorithm.\n""","""obNvpQ[VASŶ߂\tMomentum RateA\n"""
"""""","""\t(Value should be between 0 - 1, Default = 0.2).""","""\t(0--1ADefault=0.2̊Ԃɂ́Alׂł)B"""
"""""","""-M <momentum>""","""-M<>"""
"""""","""\tNumber of epochs to train through.\n""",""".. \nʂČP鎞\tNumber"""
"""""","""\t(Default = 500).""","""\t(ftHg=500)B"""
"""""","""-N <number of epochs>""","""-N<̐>"""
"""""","""\tPercentage size of validation set to use to terminate""","""@\tPercentageTCÝAI邽߂ɎgpɃZbg܂B"""
"""""",""" training (if this is non zero it can pre-empt num of epochs.\n""",""" g[jOA(ꂪ[łȂA͎\nnum肷邱Ƃł܂B"""
"""""","""\t(Value should be between 0 - 100, Default = 0).""","""\t(0--100ADefault=0̊Ԃɂ́Alׂł)B"""
"""""","""-V <percentage size of validation set>""","""-V<@̊TCY̓Zbg܂>"""
"""""","""\tThe value used to seed the random number generator""","""tThelɎ̂Ɏgp\"""
"""""","""\t(Value should be >= 0 and and a long, Default = 0).""","""āA\t((l͂łׂł>)=0AāA=Default0)B"""
"""""","""\tThe consequetive number of errors allowed for validation""","""tThe consequetiveԍ@̂߂ɋe\"""
"""""",""" testing before the netwrok terminates.""",""" netwrok̑OŃeXĝ͏I܂B"""
"""""","""\t(Value should be > 0, Default = 20).""","""\t(l>0ADefault=20łׂł)B"""
"""""","""-E <threshold for number of consequetive errors>""","""-E<consequetive̐̂߂̕~>"""
"""""","""\tGUI will be opened.\n""","""\tGUIJA\n"""
"""""","""\t(Use this to bring up a GUI).""","""\t(GUIė̂ɂgp܂)B"""
"""""","""\tAutocreation of the network connections will NOT be done.\n""","""lbg[Nڑ\tAutocreation. \nȂł傤B"""
"""""","""\t(This will be ignored if -G is NOT set)""","""\t(-Gݒ肳ȂƁA͖ł傤)"""
"""""","""\tA NominalToBinary filter will NOT automatically be used.\n""","""tA NominalToBinarytB^[ɂ\IɎgpȂA\n"""
"""""","""\t(Set this to not use a NominalToBinary filter).""","""\t(NominalToBinarytB^gpȂ悤ɐݒ肵܂)B"""
"""""","""\tThe hidden layers to be created for the network.\n""","""Bꂽ\tThelbg[N̂߂ɍ쐬邽߂ɑwɂA\n"""
"""""","""\t(Value should be a list of comma seperated Natural numbers""","""\tA(l̓R}seperated Naturalԍ̃XgłׂłB"""
"""""",""" or the letters 'a' = (attribs + classes) / 2, 'i'""",""" '莆'a'=(attribs+NX)/2Ai'"""
"""""",""" = attribs, 'o' = classes, 't' = attribs .+ classes)""",""" = 'attribsA'o'='=attribsłȂ܂B+͑܂)"""
"""""",""" For wildcard values""",""" ChJ[hl̂߂"""
"""""",""",Default = a).""","""Default=a)"""
"""""","""-H <comma seperated numbers for nodes on each layer>""","""-H<ew̃m[h̃R}seperatedԍ>"""
"""""","""\tNormalizing a numeric class will NOT be done.\n""","""lNXtNormalizing\. \nȂł傤B"""
"""""","""\t(Set this to not normalize the class if it's numeric).""","""\t(ݒ肳āANX𐳏ɂȂ͂łȂ琔lł)B"""
"""""","""\tNormalizing the attributes will NOT be done.\n""","""tNormalizing\. \nȂł傤B"""
"""""","""\t(Set this to not normalize the attributes).""","""\t(ɑ𐳏ɂȂ悤ɐݒ肵܂)B"""
"""""","""\tReseting the network will NOT be allowed.\n""",""".. \n̓lbg[NtReseting\ɋeȂł傤B"""
"""""","""\t(Set this to not allow the network to reset).""","""\t(ɃZbgւ̃lbg[NeȂ悤ɐݒ肵܂)B"""
"""""","""\tLearning rate decay will occur.\n""","""[gstLearning\NA\n"""
"""""","""\t(Set this to cause the learning rate to decay).""","""\t(ɊwKĤN悤ɐݒ肵܂)B"""
"""""","""Sigmoid ""","""S"""
"""""","""Linear ""","""I"""
"""""","""Node ""","""m[h"""
"""""","""\n    Inputs    Weights\n""","""\n͏d\n͂܂B"""
"""""","""    Threshold    """,""" ~"""
"""""","""\n    Input\n""","""\n\n͂܂B"""
"""""","""    Attrib """,""" Attrib"""
"""""","""    Node """,""" m[h"""
"""""","""This neural network uses backpropagation to train.""","""̃j[Elbg[ŃAP̂ɃobNvpQ[Vgp܂B"""
"""""","""The amount the""",""""""
"""""",""" weights are updated.""",""" dAbvf[g܂B"""
"""""","""Momentum applied to the weights during updating.""","""Abvf[g̊ԂɏdɓKpꂽB"""
"""""","""Adds and connects up hidden layers in the network.""","""lbg[NŉBꂽwāAȂ܂B"""
"""""","""Seed used to initialise the random number generator.""","""q͈ȑO͂悭Ă܂B"""
"""""","""Random numbers are used for setting the initial weights of the""","""̏dݒ肵܂gpĂB"""
"""""",""" connections betweem nodes, and also for shuffling the training data.""",""" ڑ́Am[hbetweemāA܂Ag[jOf[^Vbt邽߂ɂ܂B"""
"""""","""Used to terminate validation testing.""","""FÎɂāAgpĂ܂B"""
"""""","""The value here dictates how many times in a row the validation set""","""̒ĺA@ŁAZbg߂܂B"""
"""""",""" error can get worse before training is terminated.""",""" g[jOIOɌ́A舫Ȃ邱Ƃł܂B"""
"""""","""Brings up a gui interface.""","""guiC^tF[Xł́Aė܂B"""
"""""",""" This will allow the pausing and altering of the nueral network""",""" nuerallbg[N̎~܂ƕς邱Ƃł傤B"""
"""""",""" during training.\n\n""",""" g[jO\n\n̊"""
"""""","""* To add a node left click (this node will be automatically selected,""","""* m[ĥ͍NbN܂B(IāÃm[h͎IɂɂȂł傤B"""
"""""",""" ensure no other nodes were selected).\n""",""" ̃m[hSIȂ̂mɂĂA). \n"""
"""""","""* To select a node left click on it either while no other node is""","""* ̂ǂȃm[hIĂȂԁAŃm[hNbNI邽߂"""
"""""",""" selected or while holding down the control key (this toggles that""",""" cI邩A܂͐L[̉Ƃ߂ĂA(͂؂芷܂B"""
"""""",""" node as being selected and not selected.\n""",""" m[hAIĂ. \nI܂B"""
"""""","""* To connect a node, first have the start node(s) selected, then click""","""* m[hڑāAŏɁAX^[gm[hIāAɁANbN邽߂"""
"""""",""" either the end node or on an empty space (this will create a new node""",""" Ghm[h󂫃Xy[XA(͐Vm[h쐬ł傤B"""
"""""",""" that is connected with the selected nodes). The selection status of""",""" ꂪIꂽm[hɊ֘AÂA) I"""
"""""",""" nodes will stay the same after the connection. (Note these are""",""" m[h͐ڑ̌ɓ܂܂ł傤B ("""
"""""",""" directed connections, also a connection between two nodes will not""",""" wꂽڑA2̃m[h̊Ԃ̐ڑȂł傤B"""
"""""",""" be established more than once and certain connections that are""",""" mx葽ĊmMĂڑɂȂĂB"""
"""""",""" deemed to be invalid will not be made).\n""",""" ł̂ȂƍlA). \n"""
"""""","""* To remove a connection select one of the connected node(s) in the""","""* ڑO߂ɁAŐڑm[h1I܂B"""
"""""",""" connection and then right click the other node (it does not matter""",""" ڑƂ̎Е̃m[hENbNA(͏dvł͂܂B"""
"""""",""" whether the node is the start or end the connection will be removed""",""" m[hڑOn߂Ił"""
"""""","""* To remove a node right click it while no other nodes (including it)""","""* m[h菜߂ɁÃm[hłȂԁAENbN܂B(܂ł܂)"""
"""""",""" are selected. (This will also remove all connections to it)\n.""",""" I܂B (܂Aׂ͂Ă̐ڑɊOł傤)\nB"""
"""""","""* To deselect a node either left click it while holding down control,""","""* deselectƁAm[h̓Rg[ĂԁANbN܂B"""
"""""",""" or right click on empty space.\n""",""" ܂́A󂫃Xy[X\nENbNĂB"""
"""""","""* The raw inputs are provided from the labels on the left.\n""","""* ̃x琶̓͂񋟂A\n"""
"""""","""* The red nodes are hidden layers.\n""","""* Ԃm[hBꂽwłA\n"""
"""""","""* The orange nodes are the output nodes.\n""","""* IW̃m[ho̓m[hłA\n"""
"""""","""* The labels on the right show the class the output node represents.""","""* Ẽx͏o̓m[h\NX܂B"""
"""""",""" Note that with a numeric class the output node will automatically be""",""" lNXƋɁAo̓m[hIɂ̂ɒӂĂB"""
"""""",""" made into an unthresholded linear unit.\n\n""",""" unthresholdedIȃjbg\n\nɍĂ܂B"""
"""""","""Alterations to the neural network can only be done while the network""","""lbg[NłԁAj[Elbg[NɕύX邱Ƃł邾łB"""
"""""",""" is not running, This also applies to the learning rate and other""",""" ܂AsAThiswł郌[gőɓKpƂƂł͂܂B"""
"""""",""" fields on the control panel.\n\n""",""" Rg[̂ƂɁApl\n\n΂܂B"""
"""""","""* You can accept the network as being finished at any time.\n""","""* ȂAlbg[NłIƎ󂯓邱ƂłA\n"""
"""""","""* The network is automatically paused at the beginning.\n""","""* lbg[Nn߂ɎIɃ|[YA\n"""
"""""","""* There is a running indication of what epoch the network is up to""","""* lbg[NǂȎ̑s邵邩B"""
"""""",""" and what the (rough) error for that epoch was (or for""",""" ܂͂̎(r)̌肪ł邩ƂƂłA(B"""
"""""",""" the validation if that is being used). Note that this error value""",""" @łȂgpĂA) ̌肪]钍"""
"""""",""" is based on a network that changes as the value is computed.""",""" lvZ悤ɕωlbg[NɊÂĂ܂B"""
"""""",""" (also depending on whether""",""" (܂A܂B"""
"""""",""" the class is normalized will effect the error reported for numeric""",""" NX͐ɂāAl̂߂ɕ񍐂ꂽɍpƂƂłB"""
"""""",""" classes.\n""",""" NX\n"""
"""""","""* Once the network is done it will pause again and either wait to be""","""* lbg[NłȂƁAĂю~܂ł傤AāAǂ炩A~܂̂҂Ă܂B"""
"""""",""" accepted or trained more.\n\n""",""" 󂯓ꂽPꂽȏ\n\n"""
"""""","""Note that if the gui is not set the network will not require any""","""guiݒ肳Ȃƃlbg[NKvƂȂ̂ɒӂĂB"""
"""""",""" interaction.\n""",""" ݍp\n"""
"""""","""The percentage size of the validation set.""","""@̊TCY̓Zbg܂B"""
"""""","""(The training will continue until it is observed that""","""(ꂪϑ܂Ńg[jOA"""
"""""",""" the error on the validation set has been consistently getting""",""" @Zbgɂ͈тē邱ƂłB"""
"""""",""" worse, or if the training time is reached).\n""",""" ЂǂA܂̓g[jOE^CɒBĂA). \n"""
"""""","""If This is set to zero no validation set will be used and instead""","""This[ɐݒ肳ƁA@Zbg͑SɎgpȂł傤B"""
"""""",""" the network will train for the specified number of epochs.""",""" lbg[N͎̎w肳ꂽɔČPł傤B"""
"""""","""The number of epochs to train through.""","""P鎞̐B"""
"""""",""" If the validation set is non-zero then it can terminate the network""",""" @Zbg[łȂA̓lbg[NI邱Ƃł܂B"""
"""""",""" early""",""" """
"""""","""This will preprocess the instances with the filter.""","""̓tB^ŗOł傤B"""
"""""",""" This could help improve performance if there are nominal attributes""",""" ́Aڏ̑ΐ\コ̂邩܂B"""
"""""",""" in the data.""",""" f[^ŁB"""
"""""","""This defines the hidden layers of the neural network.""","""̓j[Elbg[N̉Bꂽw`܂B"""
"""""",""" This is a list of positive whole numbers. 1 for each hidden layer.""",""" ͗z̐̃XgłB 1 ꂼ̉Bꂽŵ߂ɁB"""
"""""",""" Comma seperated. To have no hidden layers put a single 0 here.""",""" R}seperated܂B BꂽwSĂȂ̂͂ɂ0u܂B"""
"""""",""" This will only be used if autobuild is set. There are also wildcard""",""" autobuildݒ肳ꍇɂA͎gpł傤B ChJ[h܂B"""
"""""",""" values 'a' = (attribs + classes) / 2, 'i' = attribs, 'o' = classes""",""" 'a'=(attribs+NX)/2A'i'=attribs'o'=NX]܂B"""
"""""",""" , 't' = attribs + classes.""",""" , 'ǂ'=attribs+܂B"""
"""""","""This will normalize the class if it's numeric.""","""ꂪlłȂA̓NX𐳏ɂł傤B"""
"""""",""" This could help improve performance of the network, It normalizes""",""" ́Albg[N̐\コ̂邩ȂāAIt͐ɂ܂B"""
"""""",""" the class to be between -1 and 1. Note that this is only internally""",""" -11̊ԂNXB ꂪIɂł̂ɒӂĂB"""
"""""",""", the output will be scaled back to the original range.""",""", o͂͌̃NXɍ킹ĒԂł傤B"""
"""""","""This will normalize the attributes.""","""͑𐳏ɂł傤B"""
"""""",""" This could help improve performance of the network.""",""" ́Albg[N̐\コ̂邩܂B"""
"""""",""" This is not reliant on the class being numeric. This will also""",""" ͐lłNXɗĂ܂B ܂A͂ł傤B"""
"""""",""" normalize nominal attributes as well (after they have been run""",""" ܂Aڏ̑𐳏ɂĂA(sĂ܂B"""
"""""",""" through the nominal to binary filter if that is in use) so that the""",""" ʂāA2ĩtB^ւ̖ڏオłȂgp) ɂA"""
"""""",""" nominal values are between -1 and 1""",""" zʉi-11̊Ԃ܂B"""
"""""","""This will allow the network to reset with a lower learning rate.""","""͒ႢwKŃZbgւ̃lbg[Neł傤B"""
"""""",""" If the network diverges from the answer this will automatically""",""" lbg[NꂪIɂ铚炻Ȃ"""
"""""",""" reset the network with a lower learning rate and begin training""",""" ႢwKŃlbg[NZbgĂAāAPn߂ĂB"""
"""""",""" again. This option is only available if the gui is not set. Note""",""" ĂсB guiݒ肳ȂꍇɂÃIvV͗p\łB """
"""""",""" that if the network diverges but isn't allowed to reset it will""",""" Albg[N򂷂ȂA͂ꂪ郊ZbgɋeĂ܂B"""
"""""",""" fail the training process and return an error message.""",""" g[jOvZXɎsĂAāAG[bZ[WԂĂB"""
"""""","""This will cause the learning rate to decrease.""","""ŁAwK͌ł傤B"""
"""""",""" This will divide the starting learning rate by the epoch number, to""",""" ͎ԍɎn߂̊wKł傤B"""
"""""",""" determine what the current learning rate should be. This may help""",""" ݂̊wKǂ̂炢łׂł邩肵ĂB ͏邩܂B"""
"""""",""" to stop the network from diverging from the target output, as well""",""" lbg[N܂Ao͂ꂽڕW炻̂~߂邽߂"""
"""""",""" as improve general performance. Note that the decaying learning""",""" ʓIȐ\コ̂ŁB ɒӂĂAHwK"""
"""""",""" rate will not be shown in the gui, only the original learning rate""",""" [gguiÅwKŎȂł傤B"""
"""""",""". If the learning rate is changed in the gui, this is treated as the""",""".. guiŊwKςȂA܂B"""
"""""",""" starting learning rate.""",""" wюn߂āA]ĂB"""
"""""","""Too many support points. ""","""߂̂|CgT|[g܂B"""
"""""","""distribution of the mixture of non-central Chi-square\n""","""񒆉Chi`\n̍̕z"""
"""""","""   0.5 * Chi^2_1(ncp1) + 0.5 * Chi^2_1(ncp2)\n""",""" 0.5 ^2_1(ncp2)*L[^2_1(ncp1)+0.5*L[~n"""
"""""","""It also tests the PACE estimators. Quadratic losses of the\n""","""܂APACEςleXg܂B \n̓񎟂̑"""
"""""","""estimators are given, measuring their performance.""","""ނ̐\𑪒肵āAςl^܂B"""
"""""","""ncp1 = ""","""ncp1="""
"""""",""" ncp2 = """,""" ncp2="""
"""""","""The estimated mixing distribution is\n""","""悻z\nłB"""
"""""","""\nThe PACE2 Estimate = \n""","""\nThe PACE2=\nς܂B"""
"""""","""\nThe PACE4 Estimate = \n""","""\nThe PACE4=\nς܂B"""
"""""","""\nThe PACE6 Estimate = \n""","""\nThe PACE6=\nς܂B"""
"""""","""sizes not match""","""TCY͍܂B"""
"""""","""Points""","""|Cg"""
"""""","""Values""","""l"""
"""""","""d (after normalize) = \n""","""d(ɁAɂ)=\n"""
"""""","""d (after setting [1]) = \n""","""d(1ݒ肵)=\n"""
"""""","""d (after sorting) = \n""","""d(\[eBǑ)=\n"""
"""""","""d (after unique) = \n""","""d(j[Nł)=\n"""
"""""","""sizes unmatch""","""u-}b`v傫ŕ܂B"""
"""""","""index.size() > length ""","""index.size()>"""
"""""","""zero size""","""[TCY"""
"""""","""digits < 1""","""P^<1"""
"""""","""flexible width""","""tLVuȕ"""
"""""","""insufficient capacity""","""s\ȗe"""
"""""","""i1 < i0 ""","""i1<i0"""
"""""","""null vector""","""kxNg"""
"""""","""standard deviation <= 0.0""","""W΍<=0.0"""
"""""","""standard deviation < 0.0""","""W΍<0.0"""
"""""","""unknown method""","""m̃\bh"""
"""""","""The mixing distribution:\n""","""z: \n"""
"""""","""data size < 2""","""f[^TCY<2"""
"""""","""This is to test the estimation of the mixing\n""","""́A\ňςeXg邽߂̂̂łB"""
"""""","""distribution of the mixture of unit variance normal\n""","""jbgω̐\n̍̕z"""
"""""","""distributions. The example mixture used is of the form: \n\n""","""zB gp̍̓tH[̂̂ł: \n\n"""
"""""","""   0.5 * N(mu1, 1) + 0.5 * N(mu2, 1)\n""",""" 0.5 *N(mu1A1)+0.5*N(mu2A1)\n"""
"""""","""It also tests three estimators: the subset\n""","""܂A3ľςleXg܂: W\n"""
"""""","""selector, the nested model selector, and the empirical Bayes\n""","""ZN^AqɂꂽfZN^AюؓIȃxCY\n"""
"""""","""estimator. Quadratic losses of the estimators are given, \n""","""ςlB ςl̓񎟂͓̑R̂ƁA\nłB"""
"""""","""and are taken as the measure of their performance.""","""āAނ̐\̎iƂāA܂B"""
"""""","""mu1 = ""","""mu1="""
"""""",""" mu2 = """,""" mu2="""
"""""",""" observations are: \n\n""",""" ϑ͈ȉ̒ʂłB \n\n"""
"""""","""\nQuadratic loss of the raw data (i.e., the MLE) = ""","""f[^(Ȃ킿AMLE)=\nQuadratic̑"""
"""""","""The estimated mixing distribution is:\n""","""ςāAzāA: \nłB"""
"""""","""\nThe Nested Estimate = \n""","""\nThe͌ς=\nqɂ܂B"""
"""""","""\nThe Subset Estimate = \n""","""\nTheWς=\n"""
"""""","""\nThe Empirical Bayes Estimate = \n""","""\nThe̎ؓIȃxCYEstimate=\n"""
"""""","""Index out of bounds""","""OɍĂB"""
"""""","""sizes not match.""","""TCY͍܂B"""
"""""","""null matrix""","""k}gNX"""
"""""","""unequal numbers of rows.""","""sȐ̗B"""
"""""","""unequal numbers of rows: ""","""sȐ̗: """
"""""","""Does not converge""","""_ɏW߂܂B"""
"""""","""To test the pace estimators of linear model\n""","""`f\ñy[XςleXg邽߂"""
"""""","""coefficients.\n""","""W\n"""
"""""","""The data set contains ""","""f[^Zbg͊܂ł܂B"""
"""""",""" observations plus """,""" ϑvX"""
"""""",""" variables.\n\nThe coefficients of the true model""",""" ϐfn~\nTheW"""
"""""",""" are:\n\n""",""" : \n\nłB"""
"""""","""\nThe standard deviation of the error term is ""","""덷\nTheW΍͂łB"""
"""""","""The OLS estimate (by jama.Matrix.solve()) is:\n\n""","""OLS͌ς܂B(jama.Matrix.solve())͈ȉ̒ʂA\n\n"""
"""""","""\nThe OLS estimate (through lsqr()) is: \n\n""","""\nThe OLSςA(ʂāAlsqr())͈ȉ̒ʂłB \n\n"""
"""""","""\nQuadratic loss of the OLS estimate (||X b - X bHat||^2) = """,""""""
"""""","""             *** Pace estimation *** \n""",""" *** y[Xς*** \n"""
"""""","""Estimated standard deviation = ""","""W΍="""
"""""","""\naHat = \n""","""\naHat=\n"""
"""""","""\n========= Based on chi-square mixture ============""","""\n========= L[`ɊÂĂ܂B============"""
"""""","""\nThe pace2 estimate of coefficients = \n""","""nThe pace2ςW=\n\"""
"""""","""\nThe pace4 estimate of coefficients = \n""","""nThe pace4ςW=\n\"""
"""""","""\nThe pace6 estimate of coefficients = \n""","""nThe pace6ςW=\n\"""
"""""","""\n========= Based on normal mixture ============""","""\n========= ʏ̍ɊÂĂ܂B============"""
"""""","""\nEstimated mixing distribution is:\n""","""\AnEstimatedāAzāA: \nłB"""
"""""","""The nested estimate of coefficients = \n""","""W=\n̓qɂꂽς"""
"""""","""\nThe subset estimate of coefficients = \n""","""W=\n\nTheWς"""
"""""","""\nThe empirical Bayes estimate of coefficients = \n""","""W=\n\nThe̎ؓIȃxCYς"""
"""""","""Quadratic loss = ""","""񎟂̑="""
"""""","""Ordinary least squares""","""ŏ2搄@"""
"""""","""Empirical Bayes""","""ؓIȃxCY"""
"""""","""Nested model selector""","""qɂꂽfZN^"""
"""""","""Subset selector""","""WZN^"""
"""""","""PACE2""",""""""
"""""","""PACE4""",""""""
"""""","""PACE6""",""""""
"""""","""Ordinary least squares selection""","""ŏ2搄@I"""
"""""","""AIC""","""ACN"""
"""""","""BIC""",""""""
"""""","""RIC""","""bN"""
"""""","""Class for building pace regression linear models and using them for ""","""`fy[XAɑāAނgp邽߂ɁA܂B"""
"""""","""prediction. \n\n""","""\B \n\n"""
"""""","""Under regularity conditions, pace regression is provably optimal when ""","""KԂ̉ł́Ay[XAؖ\ɂłAœKłA"""
"""""","""the number of coefficients tends to infinity. It consists of a group of ""","""W͖̐ŌX܂B ̓O[v琬܂B"""
"""""","""estimators that are either overall optimal or optimal under certain ""","""IȍœḰA܂́AœK̉̊mMĂ錩ςl"""
"""""","""conditions.\n\n""",""" \n\n"""
"""""","""The current work of the pace regression theory, and therefore also this ""","""y[XA_AтāÂ݂̎d"""
"""""","""implementation, do not handle: \n\n""","""AȉȂłB \n\n"""
"""""","""- missing values \n""","""- l\n"""
"""""","""- non-binary nominal attributes \n""","""- oCi[ڏ̑\n"""
"""""","""- the case that n - k is small where n is the number of instances and k is ""","""- nP[XɓĂ--kn̐łƂŏłAāAk͏łB"""
"""""","""the number of coefficients (the threshold used in this implmentation is 20)\n\n""","""W(implmentationŎgp~20ł)\n\n̐"""
"""""","""For more information see:\n\n""","""ڂɊւẮA: \n\nĂB"""
"""""","""Wang, Y. (2000). A new approach to fitting linear models in high """,""""""
"""""","""dimensional spaces. PhD Thesis. Department of Computer Science, """,""""""
"""""","""University of Waikato, New Zealand. \n\n""",""""""
"""""","""Wang, Y. and Witten, I. H. (2002). Modeling for optimal probability """,""""""
"""""","""prediction. Proceedings of ICML'2002. Sydney.""",""""""
"""""",""" for pace regression!""",""" y[XÂ߂!"""
"""""","""Can only deal with numeric and binary attributes!""","""ĺAāA2ȋɑΏ邱Ƃł邾ł!"""
"""""","""Not enough instances. Ratio of number of instances (n) to number of ""","""\ȗłȂB (n)̐ΐ̔䗦"""
"""""","""attributes (k) is too small (n - k < 20).""","""(k)͏߂܂(n--k<20)B"""
"""""","""Can't handle missing values!""","""lƂł܂!"""
"""""","""Pace Regression: No model built yet.""","""Aɕ킹Ă: ǂȃf܂ĂĂ܂łB"""
"""""","""\nPace Regression Model\n\n""","""\nPaceAf\n\n"""
"""""","""\tProduce debugging output.\n""","""\tProducefobOo\n"""
"""""","""\t(default no debugging output)""","""\t(o͂fobOȂftHg)"""
"""""","""\tThe estimator can be one of the following:\n""","""\tTheςl: ȉ1\nłȂ炻邱Ƃł܂B"""
"""""","""\t\teb\tEmpirical Bayes(default)\n""","""\t\teb\tEmpiricalxCY(ftHg)\n"""
"""""","""\t\tnested\tOptimal nested model\n""","""\t\\tOptimalqɂꂽf\ntnested܂B"""
"""""","""\t\tsubset\tOptimal subset\n""","""\t\tsubset\tOptimalW\n"""
"""""","""\t\tpace2\tPACE2\n""",""""""
"""""","""\t\tpace4\tPACE4\n""",""""""
"""""","""\t\tpace6\tPACE6\n\n""",""""""
"""""","""\t\tols\tOrdinary least squares\n""","""\t\tols\tOrdinary\nłŏɓ悵܂B"""
"""""","""\t\taic\tAIC\n""",""""""
"""""","""\t\tbic\tBIC\n""",""""""
"""""","""\t\tric\tRIC\n""",""""""
"""""","""\t\tolsc\tOLSC""",""""""
"""""","""-E <estimator>""","""-E<ςl>"""
"""""","""\tThreshold value for the OLSC estimator""","""tThresholdOLSCςl̂߂ɕ]\"""
"""""","""-S <threshold value>""","""-S<臒l>"""
"""""","""unknown estimator ""","""m̌ςl"""
"""""",""" for -E option""",""" -EIvV̂߂"""
"""""","""ols""",""""""
"""""","""olsc""",""""""
"""""","""nested""","""܂B"""
"""""","""subset""","""W"""
"""""","""pace2""",""""""
"""""","""pace4""",""""""
"""""","""pace6""",""""""
"""""","""aic""",""""""
"""""","""bic""",""""""
"""""","""ric""",""""""
"""""","""Output debug information to the console.""","""R\[ɃfobOo͂ĂB"""
"""""","""The estimator to use.\n\n""",""".. \n\ngp錩ςl"""
"""""","""eb -- Empirical Bayes estimator for noraml mixture (default)\n""","""eb--noraml(ftHg)\n̎ؓIȃxCYςl"""
"""""","""nested -- Optimal nested model selector for normal mixture\n""","""܂--Aȍ\n̍œK̓qɂꂽfZN^"""
"""""","""subset -- Optimal subset selector for normal mixture\n""","""W--ȍ\n̍œK̕WZN^"""
"""""","""pace2 -- PACE2 for Chi-square mixture\n""","""pace2--Chi-`\nPACE2"""
"""""","""pace4 -- PACE4 for Chi-square mixture\n""","""pace4--Chi-`\nPACE4"""
"""""","""pace6 -- PACE6 for Chi-square mixture\n""","""pace6--Chi-`\nPACE6"""
"""""","""ols -- Ordinary least squares estimator\n""","""ols--ŏ2搄@ςl\n"""
"""""","""aic -- AIC estimator\n""","""aic--ACNςl\n"""
"""""","""bic -- BIC estimator\n""","""bic--BICςl\n"""
"""""","""ric -- RIC estimator\n""","""ric--RICςl\n"""
"""""","""olsc -- Ordinary least squares subset selector with a threshold""","""olsc--~ŏ2搄@WZN^"""
"""""","""Threshold for the olsc estimator.""","""olscςl̂߂̕~B"""
"""""","""Class that implements a normalized Gaussian radial basis""","""ɂꂽGaussianåbNX"""
"""""","""basis function network. ""","""b@\lbg[NB"""
"""""","""It uses the k-means clustering algorithm to provide the basis ""","""́Ab񋟂̂k-iNX^OASYgp܂B"""
"""""","""functions and learns either a logistic regression (discrete ""","""@\āAWXeBNX̕AwԁA(UI"""
"""""","""class problems) or linear regression (numeric class problems) ""","""NX)AIȕA(lNX) """
"""""","""on top of that. Symmetric multivariate Gaussians are fit to ""","""̏ɁB GaussiansKCł鍶EΏ̂̑ϗ"""
"""""","""the data from each cluster. If the class is ""","""ꂼꂩ̃f[^̓NX^O܂B NXȂ"""
"""""","""nominal it uses the given number of clusters per class.""","""ڏA1NX̃NX^̗^ꂽgp܂B"""
"""""","""It standardizes all numeric ""","""ׂ͂Ă̐lW܂B"""
"""""","""attributes to zero mean and unit variance.""","""[ςƃjbgωւ̑B"""
"""""","""No classifier built yet!""","""܂gĂĂȂNVt@CA!S"""
"""""","""Radial basis function network\n""","""åb@\lbg[N\n"""
"""""","""(Logistic regression ""","""(WXeBNX̕A"""
"""""","""(Linear regression ""","""(IȕA"""
"""""","""applied to K-means clusters as basis functions):\n\n""","""b@\) : \n\nƂKiNX^ɓKp܂B"""
"""""","""Maximum number of iterations for the logistic regression to perform. ""","""WXeBNX̕Aső吔̌JԂB"""
"""""","""Only applied to discrete class problems.""","""UIȃNXɓKpĂ邾łB"""
"""""","""Set the Ridge value for the logistic or linear regression.""","""WXeBNXIA܂́AIȕARidgelݒ肵ĂB"""
"""""","""The number of clusters for K-Means to generate.""","""Kî߂̃NX^̐B"""
"""""","""The random seed to pass on to K-means.""","""Kiɒʂ閳ׂ̎qB"""
"""""","""Sets the minimum standard deviation for the clusters.""","""NX^̂߂̍ŏ̕ẄẼZbgB"""
"""""","""\tSet the number of clusters (basis functions) ""","""\tSet̓NX^̐łB(b@\) """
"""""","""to generate. (default = 2).""","""邽߂ɁB (ftHg=2)."""
"""""","""-B <number>""","""-B<>"""
"""""","""\tSet the random seed to be used by K-means. ""","""ׂtSetKiŎgp邽߂Ɏ\B"""
"""""","""(default = 1).""","""(ftHg=1)."""
"""""","""\tSet the ridge value for the logistic or ""","""܂\WXeBNX̂߂ɔltSetB"""
"""""","""linear regression.""","""IȕAB"""
"""""","""-R <ridge>""","""-R<𗧂Ă܂>"""
"""""","""\tSet the maximum number of iterations ""","""\tSet͌JԂ̍ő吔łB"""
"""""","""for the logistic regression.""","""WXeBNX̕Â߂ɁB"""
"""""",""" (default -1, until convergence).""",""" (W܂ł̃ftHg-1)."""
"""""","""-M <number>""","""-M<>"""
"""""","""\tSet the minimum standard ""","""\tSet͍ŒłB"""
"""""","""deviation for the clusters.""","""NX^̂߂̈EB"""
"""""",""" (default 0.1).""",""" (ftHg0.1)."""
"""""","""-W <number>""","""-W<>"""
"""""","""Learns a simple linear regression model. ""","""ȒPȐ`Afwт܂B"""
"""""","""Picks the attribute that results in the lowest squared error. ""","""łႢƂ̌ʂ悵ɌIт܂B"""
"""""","""Missing values are not allowed. Can only deal with numeric attributes.""","""l͋eĂ܂B lɑΏ邱Ƃł邾łB"""
"""""","""SimpleLinearRegression: No missing values!""","""SimpleLinearRegression: l܂!"""
"""""","""Class attribute has to be numeric for regression!""","""AɂāANX͐lłȂ΂Ȃ܂!"""
"""""","""SimpleLinearRegression: Only numeric attributes!""","""SimpleLinearRegression: l!"""
"""""","""----- no useful attribute found""","""----- ͌܂łɗB"""
"""""","""Predicting constant ""","""萔\܂B"""
"""""","""Linear regression on ""","""IȕAAI"""
"""""","""Class attribute must be nominal.""","""NX͖ڏłɈႢ܂B"""
"""""","""No instances without missing class values in training file!""","""g[jOɂ錇ĂKl̂ȂCX^X͑St@C܂!"""
"""""","""\tSet fixed number of iterations for LogitBoost\n""","""LogitBoost\n̂߂̌JԂ̐Œ肳ꂽ\tSet"""
"""""","""-I <iterations>""","""-<JԂ>"""
"""""","""\tUse stopping criterion on training set (instead of cross-validation)\n""","""g[jO̕]~߂\tUse\nݒ肵܂(Ă鍇@̑)B"""
"""""","""\tUse error on probabilities (rmse) instead of misclassification error ""","""ތ̑Ɋm(rmse)ɂ\tUse"""
"""""","""for stopping criterion\n""","""~]\n"""
"""""","""\tSet maximum number of boosting iterations\n""","""\tSető吔ɂČJԂ\nグ邱ƁB"""
"""""","""-M <iterations>""","""-M<JԂ>"""
"""""","""\tSet parameter for heuristic for early stopping of LogitBoost.""","""LogitBoost̑~̂߂̃q[XeBbN̂߂\tSetp^B"""
"""""","""If enabled, the minimum is selected greedily, stopping if the current minimum""","""\ɂȂA݂̍ŏłȂ~܂āAŏ×~ɑI܂B"""
"""""",""" has not changed for iter iterations. By default, heuristic is enabled with""",""" iterJԂ̂߂ɁAωĂ܂B ftHgŁAq[XeBbN͉\ɂ܂B"""
"""""","""value 50. Set to zero to disable heuristic.""","""50]ĂB [ɃZbgāAq[XeBbN𖳌ɂĂB"""
"""""","""-H <iterations>""","""-H<JԂ>"""
"""""","""measureAttributesUsed""",""""""
"""""",""" not supported (SimpleLogistic)""",""" x܂B(SimpleLogistic)"""
"""""","""Classifier for building linear logistic regression models. LogitBoost with simple regression ""","""IȃWXeBNX̉Afzグ邽߂̃NVt@CAB ȒPȕALogitBoost"""
"""""","""functions as base learners is used for fitting the logistic models. The optimal number of LogitBoost ""","""x[XwK҂ƂĂ̋@\́AWXeBbNfɍ̂Ɏgp܂B LogitBoost̍œK̐"""
"""""","""iterations to perform is cross-validated, which leads to automatic attribute selection. ""","""sJԂ͏\ɂėLɂ܂(Iɒʂ܂)B"""
"""""","""Set fixed number of iterations for LogitBoost. If >= 0, this sets the number of LogitBoost iterations ""","""LogitBoostɌJԂ̒萔ݒ肵ĂB >=0łȂALogitBoostJԂ̐ݒ肵܂B"""
"""""","""to perform. If < 0, the number is cross-validated or a stopping criterion on the training set is used ""","""߂ɁB <0łȂA\ɂėLɂ邩A܂̓g[jOZbg̒~]͎gpĂ܂B"""
"""""","""(depending on the value of useCrossValidation).""","""(useCrossValidation̒lɈˑ܂)."""
"""""","""Sets whether the number of LogitBoost iterations is to be cross-validated or the stopping criterion ""","""LogitBoostJԂ̐\ɂėLɂ邩ǂƂł邩~]ݒ肵܂B"""
"""""","""on the training set should be used. If not set (and no fixed number of iterations was given), ""","""g[jÔƂɁAZbg͎gpׂłB łȂ΁AZbgĂ(JԂ̒萔S^܂ł)B"""
"""""","""the number of LogitBoost iterations is used that minimizes the error on the training set ""","""g[jOZbgŌŏɂgpLogitBoostJԂ̐"""
"""""","""(misclassification error or error on probabilities depending on errorOnProbabilities).""","""(errorOnProbabilitiesɈˑmɂ镪ތ肩)."""
"""""","""Use error on the probabilties as error measure when determining the best number of LogitBoost iterations. ""","""LogitBoostJԂ𑪒肷ƂA葪ƂprobabiltiesŌgpĂB"""
"""""","""If set, the number of LogitBoost iterations is chosen that minimizes the root mean squared error ""","""ݒ肳ȂAϕ덷ŏɂLogitBoostJԂ̐͑I΂Ă܂B"""
"""""","""(either on the training set or in the cross-validation, depending on useCrossValidation).""","""(g[jOZbgĂ鍇@łuseCrossValidationɂ܂)."""
"""""","""Sets the maximum number of iterations for LogitBoost. Default value is 500, for very small/large ""","""LogitBoostɌJԂ̍ő吔ݒ肵܂B ftHgl͔ɏ/̂߂500łB"""
"""""","""datasets a lower/higher value might be preferable.""","""f[^Zbga͉낳܂B/荂l͖]܂܂B"""
"""""","""If heuristicStop > 0, the heuristic for greedy stopping while cross-validating the number of ""","""If heuristicStop > 0A\ŗLɂĂԂ×~Ȓ~̂߂̃q[XeBbN"""
"""""","""LogitBoost iterations is enabled. This means LogitBoost is stopped if no new error minimum ""","""LogitBoostJԂ͉\ɂ܂B ́ALogitBoostVŏłȂȂ~߂̂Ӗ܂B"""
"""""","""has been reached in the last heuristicStop iterations. It is recommended to use this heuristic, ""","""ŌheuristicStopJԂł́AB܂B ̃q[XeBbNgp̂͂߂łB"""
"""""","""it gives a large speed-up especially on small datasets. The default value is 50.""","""͓ɏf[^Zbgő傫^܂B ftHgl50łB"""
"""""","""Implements John Platt's sequential minimal optimization ""","""WEvbg̘Aŏʂ̍œKs܂B"""
"""""","""algorithm for training a support vector classifier.\n\n""","""T|[gxNgNVt@CA\n\nP邽߂̃ASY"""
"""""","""normalizes all attributes by default. (In that case the coefficients ""","""ftHgłׂĂ̑𐳏ɂ܂B (̏ꍇAW"""
"""""","""in the output are based on the normalized data, not the ""","""o͂ł́Aɂꂽf[^ɊÂĂ܂B"""
"""""","""original data --- this is important for interpreting the classifier.)\n\n""","""IWĩf[^--- NVt@CA) \n\n߂̂ɁA͏dvłB"""
"""""","""Multi-class problems are solved using pairwise classification.\n\n""","""̃NX́AΏ󕪗\n\ngp邱ƂŉĂ܂B"""
"""""","""To obtain proper probability estimates, use the option that fits ""","""K؂Ȋmς𓾂ɂ́AIvVgpĂB"""
"""""","""logistic regression models to the outputs of the support vector ""","""T|[gxNg̏o͂ւ̃WXeBNX̉Af"""
"""""","""machine. In the multi-class case the predicted probabilities ""","""@BH܂B \ꂽm̑̃NXꍇ"""
"""""","""are coupled using Hastie and Tibshirani's pairwise coupling ""","""wCXeB[TibshiranȋΏJbvOgp邱ƂŁA܂B"""
"""""","""method.\n\n""","""@\n\n"""
"""""","""Note: for improved speed normalization should be turned off when """,""": ǂꂽxɂāA퉻͂^[ׂł邩B"""
"""""","""operating on SparseInstances.\n\n""","""SparseInstances\n\n쓮܂B"""
"""""","""J. Platt (1998). ""Fast Training of Support Vector """,""""""
"""""","""Machines using Sequential Minimal Optimization"". Advances in Kernel """,""""""
"""""","""Methods - Support Vector Learning, B. Schoelkopf, C. Burges, and """,""""""
"""""","""A. Smola, eds., MIT Press. \n\n""",""""""
"""""","""S.S. Keerthi, S.K. Shevade, C. Bhattacharyya, K.R.K. Murthy,  """,""""""
"""""","""""Improvements to Platt's SMO Algorithm for SVM Classifier Design"".  """,""""""
"""""","""Neural Computation, 13(3), pp 637-649, 2001.""",""""""
"""""","""pred""",""""""
"""""","""BinarySMO: No model built yet.\n""","""BinarySMO: ǂȃf܂. \nĂĂ܂łB"""
"""""","""BinarySMO\n\n""",""""""
"""""","""Machine linear: showing attribute weights, ""","""}VI: d܂B"""
"""""","""not support vectors.\n\n""","""T|[gxNg\n\nłȂ"""
"""""","""Can't print BinarySMO classifier.""","""BinarySMONVt@CA邱Ƃł܂B"""
"""""","""Sum of y(i) * alpha(i): ""","""y(i)*At@(i)̍v: """
"""""","""KKT condition 1 violated: ""","""KKT1͈ᔽ܂: """
"""""","""KKT condition 2 violated: ""","""KKT2͈ᔽ܂: """
"""""","""KKT condition 3 violated: ""","""KKT3͈ᔽ܂: """
"""""","""SMO can't handle a numeric class! Use""","""SMO͐lNXƂł܂! gp"""
"""""","""SMOreg for performing regression.""","""As邽߂SMOregB"""
"""""","""\tGamma for the RBF kernel. (default 0.01)""","""RBFJ[l̂߂\tGammaB (ftHg0.01)"""
"""""","""-L <double>""","""-L<d>"""
"""""","""\tFit logistic models to SVM outputs. ""","""SVMo͂ւ\tFitWXeBbNfB"""
"""""","""\tThe number of folds for the internal\n""","""\n̐܂ڂ\tTheԍ"""
"""""","""\tcross-validation. ""","""\tcross-@B"""
"""""","""(default -1, use training data)""","""(ftHg-1gpf[^PāA"""
"""""","""-V <double>""","""-V<d>"""
"""""","""\tThe random number seed. ""","""\tTheqB"""
"""""","""(default 1)""","""(ftHg1)"""
"""""","""The size of the kernel cache (should be a prime number). Use 0 for full cache.""","""J[lLbV(fłׂł)̃TCYB SȃLbV0gpĂB"""
"""""","""Whether to fit logistic models to the outputs (for proper ""","""o͂ɃWXeBbNfɍǂA(K"""
"""""","""probability estimates).""","""mς)"""
"""""","""The number of folds for cross-validation used to generate ""","""̂ɂĒÂ̌Ă鍇@̂߂̐܂ڂ̐"""
"""""","""training data for logistic models (-1 means use training data).""","""WXeBbNf(-1̎ig[jOf[^gp܂)̂߂Ƀf[^P܂B"""
"""""","""Random number seed for the cross-validation.""","""Ă鍇@̂߂̗qB"""
"""""","""SMO: No model built yet.""","""SMO: ǂȃf܂ĂĂ܂łB"""
"""""","""SMO\n\n""",""""""
"""""","""Classifier for classes: ""","""NX̃NVt@CA: """
"""""","""No logistic model has been fit.\n""","""ǂȃWXeBbNf. \nɍƂł͂܂B"""
"""""","""Can't print SMO classifier.""","""SMONVt@CA邱Ƃł܂B"""
"""""","""Normalize training data""","""g[jOf[^𐳏ɂĂB"""
"""""","""Standardize training data""","""g[jOf[^WĂB"""
"""""","""No normalization/standardization""","""퉻/W܂B"""
"""""","""Implements Alex Smola and Bernhard Scholkopf's sequential minimal ""","""̃AbNXEXƃo[n[hScholkopfAAŏ"""
"""""","""optimization algorithm for training a support vector regression model. ""","""T|[gxNgAfP邽߂̍œKASYB"""
"""""","""This implementation globally replaces all missing values and ""","""Ăׂ̎Ă̌lɃO[oɎđB"""
"""""","""transforms nominal attributes into binary ones. It also ""","""ڏ̑2î̂ɕς܂B """
"""""","""normalizes all attributes by default. (Note that the coefficients ""","""ftHgłׂĂ̑𐳏ɂ܂B (ɒӂĂAW"""
"""""","""in the output are based on the normalized/standardized data, not the ""","""o͂ł́AɂꂽWꂽf[^ɊÂĂ܂B"""
"""""","""original data.) ""","""IWĩf[^B) """
"""""","""For more information on the SMO algorithm, see\n\n""","""SMOASY̏ڂɊւẮA\n\nĂB"""
"""""","""Alex J. Smola, Bernhard Scholkopf (1998). ""A Tutorial on Support Vector """,""""""
"""""","""Regression"".  NeuroCOLT2 Technical Report Series - NC2-TR-1998-030.\n\n""",""""""
"""""","""S.K. Shevade, S.S. Keerthi, C. Bhattacharyya, K.R.K. Murthy,  """,""""""
"""""","""""Improvements to SMO Algorithm for SVM Regression"".  """,""""""
"""""","""Technical Report CD-99-16, Control Division Dept of Mechanical and """,""""""
"""""","""Production Engineering, National University of Singapore. """,""""""
"""""","""SMOreg can't handle a nominal class! ""","""SMOreg͖ڏ̃NXƂł܂!"""
"""""","""Use SMO for performing ""","""̂SMOgpĂB"""
"""""","""classification.""","""ށB"""
"""""","""No training instances without a missing class!""","""ĂNXȂ΃g[jOႪ܂!"""
"""""","""No training instances left after removing ""","""ǂȃg[jOOɁAcĂ܂B"""
"""""","""instance with either a weight null or a missing class!""","""d̃kĂNX̂ǂ炩CX^X!"""
"""""","""Inconsistent state ! I0, I1, I2 and I3 ""","""!I0AI1AI2AI3"""
"""""","""must cover the whole set of indices.""","""CfbNXXg̑S̏WJo[Ȃ΂Ȃ܂B"""
"""""","""Fatal error! The program failled to ""","""vIȌ! failledꂽvO"""
"""""","""initialize i_Low, iUp.""","""i_LowAiUpĂB"""
"""""","""\tThe amount up to which deviations are\n""","""\tThe͂ǂ̈E\nł邩܂ŒB܂B"""
"""""","""\ttolerated (epsilon). (default 1e-3)""","""\ttolerated܂(CvV)B (ftHg1e-3)"""
"""""","""-S <double>""","""-S<d>"""
"""""","""\tThe complexity constant C. (default 1)""","""\tTheG萔CB(ftHg1)"""
"""""","""-C <double>""","""-C<d>"""
"""""","""\tThe exponent for the ""","""\͉҂tThe܂B"""
"""""","""polynomial kernel. (default 1)""","""J[lB (ftHg1)"""
"""""","""\tGamma for the ""","""\tGamma܂B"""
"""""","""RBF kernel. (default 0.01)""","""RBFJ[lB (ftHg0.01)"""
"""""","""-G <double>""","""-G<d>"""
"""""","""\tWhether to 0=normalize/1=standardize/2=neither. ""","""0=ւ\tWhether/1𐳏ɂ܂B= = ǂ/2WȂłB"""
"""""","""(default 0=normalize)""","""(ftHg0=͐ɂ܂)"""
"""""","""\tFeature-space normalization (only for\n""","""\tFeatureXy[X̐퉻A(\n"""
"""""","""\tnon-linear polynomial kernels).""","""\tnonIȑJ[l)"""
"""""","""\tUse lower-order terms (only for non-linear\n""","""\tUsewKpA(`\n"""
"""""","""\tpolynomial kernels).""","""\tpolynomialJ[l)"""
"""""","""\tUse RBF kernel. ""","""\tUse RBFJ[lB"""
"""""","""(default poly)""","""(ftHgA|[A)"""
"""""","""\tThe size of the kernel cache. ""","""J[lLbV\tTheTCYB"""
"""""","""(default 250007, use 0 for full cache)""","""(ftHg250007ASȃLbV̗pr0)"""
"""""","""-A <int>""","""-A<int>"""
"""""","""\tThe tolerance parameter. ""","""\tTheep^B"""
"""""","""(default 1.0e-3)""","""(ftHg1.0e-3)"""
"""""","""-T <double>""","""-T<d>"""
"""""","""\tThe epsilon for round-off error. ""","""ɃEĥ߂\tTheCvVB"""
"""""","""(default 1.0e-12)""","""(ftHg1.0e-12)"""
"""""","""-P <double>""","""-P<d>"""
"""""","""RBF machine doesn't require feature-space normalization.""","""RBF}V͓F퉻KvƂ܂B"""
"""""","""Can't use feature-space normalization with linear machine.""","""Iȃ}VɂF퉻gp邱Ƃł܂B"""
"""""","""Can't use lower-order terms with RBF machine.""","""RBFƂ̗pꂪ@BH鉺wKgp邱Ƃł܂B"""
"""""","""Can't use lower-order terms with linear machine.""","""Iȃ}V鉺wKpgp邱Ƃł܂B"""
"""""","""Determines how/if the data will be transformed.""","""/f[^łȂǂ̂悤ɕς邩肵܂B"""
"""""","""The exponent for the polynomial kernel.""","""J[l̂߂̉ҁB"""
"""""","""The value of the gamma parameter for RBF kernels.""","""RBFJ[l̂߂̃K}p^̒lB"""
"""""","""The complexity parameter C.""","""Gp^CB"""
"""""","""The tolerance parameter (shouldn't be changed).""","""ep^(ςׂł͂܂)B"""
"""""","""The epsilon for round-off error (shouldn't be changed).""","""ɃEh(ςׂłȂ)̂߂̃CvVB"""
"""""","""The amount up to which deviations are tolerated. ""","""EeʁB"""
"""""","""Watch out, the value of epsilon is used with the (normalized/standardized) ""","""Oł́ACvV̒lgprv(ɂ邩A܂͕W܂) """
"""""","""data.""","""f[^B"""
"""""","""The size of the kernel cache (should be a prime number).""","""J[lLbV(fłׂł)̃TCYB"""
"""""","""Whether to use an RBF kernel instead of a polynomial one.""","""1̑RBFJ[lgp܂?"""
"""""","""Whether feature-space normalization is performed (only ""","""F퉻sA(B"""
"""""","""Whether lower order polyomials are also used (only ""","""܂AwKpolyomialsgpA(B"""
"""""","""available for non-linear polynomial kernels).""","""`̑J[lɗp\łA)"""
"""""","""SMOreg : No model built yet.""","""SMOreg: ǂȃf܂ĂĂ܂łB"""
"""""","""SMOreg\n\n""",""""""
"""""","""Kernel used : \n""","""J[l͎gp܂: \n"""
"""""","""  RBF kernel : K(x,y) = e^-(""",""" RBFJ[l: K(xAy)=e^A-A("""
"""""","""* <x-y,x-y>^2)""",""""""
"""""","""  Linear Kernel : K(x,y) = <x,y>""",""" IȃJ[l: K(xAy)=<xAy>"""
"""""","""  Normalized Poly Kernel with lower order : K(x,y) = (<x,y>+1)^""",""" wK鐳ɂꂽPoly Kernel: K(xAy)=(<xAy>)+1) ^"""
"""""","""((<x,x>+1)^""","""(<xAx>+1) ^"""
"""""","""(<y,y>+1)^""","""<yAy>+1)^"""
"""""","""  Normalized Poly Kernel : K(x,y) = <x,y>^""",""" ɂꂽ|[J[l: K(x,y) = <x,y>^"""
"""""","""  Poly Kernel with lower order : K(x,y) = (<x,y> + 1)^""",""" wK|[Kernel: K(xAy)=(<xAy>)+1) ^"""
"""""","""  Poly Kernel : K(x,y) = <x,y>^""",""" |[J[l: K(x,y) = <x,y>^"""
"""""","""LINEAR TRANSFORMATION APPLIED : \n""","""ꎟϊ͓Kp܂: \n"""
"""""","""Machine Linear: showing attribute weights, ""","""}VI: d܂B"""
"""""","""not support vectors.\n""","""T|[gxNg\nłȂ"""
"""""","""(standardized) ""","""(W)łB """
"""""","""(normalized) ""","""(ɂ)łB """
"""""","""attribute with index ""","""CfbNX鑮"""
"""""","""Support Vector Expansion :\n""","""T|[gxNgg: \n"""
"""""","""\n\nNumber of support vectors: ""","""T|[gxNg\n\nNumber: """
"""""","""\n\nNumber of kernel evaluations: ""","""J[l]\n\nNumber: """
"""""","""% cached)""","""%LbVA)"""
"""""","""Can't print the classifier.""","""NVt@CA邱Ƃł܂B"""
"""""","""Warning! I0 contains an incorrect indice.""","""x! I0͕smȁus-TCRv܂ł܂B"""
"""""","""Fatal error! I1 contains an incorrect indice.""","""vIȌ! I1͕smȁus-TCRv܂ł܂B"""
"""""","""Fatal error! I2 contains an incorrect indice.""","""vIȌ! I2͕smȁus-TCRv܂ł܂B"""
"""""",""" appears in two different sets.""",""" قȂ2Zbgł́A܂B"""
"""""","""Fatal error! I3 contains an incorrect indice.""","""vIȌ! I3͕smȁus-TCRv܂ł܂B"""
"""""","""Fatal error! indice ""","""vIȌ!us-TCRv"""
"""""",""" doesn't belong to any set.""",""" ǂȃZbgɂ܂B"""
"""""","""Fatal error! Inconsistent alphas!""","""vIȌ! At@!"""
"""""","""Fatal error! Inconsistent alphas' sum = ""","""vIȌ! At@̍v="""
"""""","""\n-------- Status : ---------""","""\n-------- : ---------"""
"""""","""\n i, alpha, alpha'\n""","""'\An iAAt@AAt@'\n"""
"""""","""bLow = ""","""Ō="""
"""""","""  bUp = """,""" bUp="""
"""""","""(in I0a) bUp = min(bUp, ""","""(I0a) bUp=A(bUp"""
"""""","""(in I1) bUp = min(bUp, ""","""(I1) bUp=A(bUp"""
"""""",""")   bLow = max(bLow, """,""") Ō=őłA(ĂB"""
"""""","""(in I2) bLow = max(bLow, ""","""(I2) Ō=őłA(ĂB"""
"""""","""(in I3) bUp = min(bUp, ""","""(I3) bUp=A(bUp"""
"""""","""Improvements to SMO Algorithm for SVM Regression""","""SVMÂ߂SMOASYւ̉"""
"""""","""Warning! Optimality not reached : inequation (6) doesn't hold!""","""x! œKɒB܂ł: us-v(6)͎܂!"""
"""""","""Warning! Optimality not reached : inequation (8a) doesn't hold for ""","""x! œKɒB܂ł: (8a)Ȃus-v"""
"""""","""Warning! Optimality not reached : inequation (8b) doesn't hold for ""","""x! œKɒB܂ł: (8b)Ȃus-v"""
"""""","""Warning! Optimality not reached : inequation (8c) doesn't hold for ""","""x! œKɒB܂ł: (8c)Ȃus-v"""
"""""","""Warning! Optimality not reached : inequation (8d) doesn't hold for ""","""x! œKɒB܂ł: (8d)Ȃus-v"""
"""""","""Implementation of the voted perceptron algorithm by Freund and ""","""ătChɂ铊[ꂽp[ZvgASY̎B"""
"""""","""Schapire. Globally replaces all missing values, and transforms ""","""SchapireB ׂĂ̌lAѕϊO[oɎւ܂B"""
"""""","""nominal attributes into binary ones. For more information, see:\n\n""","""2î̂ւ̖ڏ̑B ڂ́A: \n\nĂB"""
"""""","""Y. Freund and R. E. Schapire (1998). Large margin """,""""""
"""""","""classification using the perceptron algorithm.  Proc. 11th """,""""""
"""""","""Annu. Conf. on Comput. Learning Theory, pp. 209-217, ACM Press, New """,""""""
"""""","""York, NY.""",""""""
"""""","""\tThe exponent for the polynomial kernel.\n""","""J[l̂߂\tTheҁA\n"""
"""""","""-E <double>""","""-E<d>"""
"""""","""\tThe seed for the random number generation.\n""","""\tThe͗̂߂. \nɎ܂B"""
"""""","""\tThe maximum number of alterations allowed.\n""",""".. \neꂽ\tTheő吔̕ύX"""
"""""","""\t(default 10000)""","""\t(ftHg10000)"""
"""""","""-M <int>""","""-M<int>"""
"""""","""VotedPerceptron: Number of perceptrons=""","""VotedPerceptron: p[Zvg=̐"""
"""""","""The maximum number of alterations to the perceptron.""","""p[Zvgւ̕ύX̍ő吔B"""
"""""","""Number of iterations to be performed.""","""sׂłJԂ̐B"""
"""""","""Exponent for the polynomial kernel.""","""J[l̂߂̉ҁB"""
"""""","""Implements Winnow and Balanced Winnow algorithms by ""","""WinnowBalanced WinnowASY^܂B"""
"""""","""Littlestone. For more information, see\n\n""","""LittlestoneB ڂ́A\n\nĂB"""
"""""","""N. Littlestone (1988). ""Learning quickly when irrelevant ""","""NB Littlestone(1988)B uu֌WłƂɁAołv"""
"""""","""attributes are abound: A new linear threshold algorithm"". ""","""͂łBxł: uVIȕ~ASYvAv """
"""""","""Machine Learning 2, pp. 285-318.\n\n""","""Learning2App@BHĂB 285-318 . \n\n"""
"""""","""and\n\n""","""āA\n\n"""
"""""","""N. Littlestone (1989). ""Mistake bounds and logarithmic  ""","""NB Littlestone(1989)B uüƑΐv"""
"""""","""linear-threshold learning algorithms"". Technical report ""","""uIȕ~wKASYvAv Zp񍐏"""
"""""","""UCSC-CRL-89-11, University of California, Santa Cruz.\n\n""","""T^NXUCSC-CRL-89-11AJtHjAwA\n\n"""
"""""","""Does classification for problems with nominal attributes ""","""ڏ̑Ɋւ̂߂ɁAނ܂B"""
"""""","""(which it converts into binary attributes).""","""(ꂪ2ȋɕϊ)."""
"""""","""\tUse the baLanced version\n""","""\tUsebaLancedo[W\nłB"""
"""""","""\tThe number of iterations to be performed.\n""","""sׂłJԂ\tTheԍA\n"""
"""""","""-I <int>""","""-<int>"""
"""""","""\tPromotion coefficient alpha.\n""","""\tPromotionWAt@\n"""
"""""","""-A <double>""","""-A<d>"""
"""""","""\tDemotion coefficient beta.\n""","""\tDemotionWx[^\n"""
"""""","""\t(default 0.5)""","""\t(ftHg0.5)"""
"""""","""-B <double>""","""-B<d>"""
"""""","""\tPrediction threshold.\n""","""\tPrediction~\n"""
"""""","""\t(default -1.0 == number of attributes)""","""\t(̃ftHg-1.0==ԍ)"""
"""""","""-H <double>""","""-H<d>"""
"""""","""\tStarting weights.\n""","""d\ntStarting\"""
"""""","""-W <double>""","""-W<d>"""
"""""","""\tDefault random seed.\n""","""\tDefaultׂ̖̎q\n"""
"""""","""-S <int>""","""-S<int>"""
"""""","""Can only handle two-class datasets!""","""2NX̃f[^ZbgƂł邾ł!"""
"""""","""Can't handle a numeric class!""","""lNXƂł܂!"""
"""""","""Winnow: only nominal attributes, ""","""Iяo܂: ڏ̑"""
"""""","""CLASS MISSING""","""NX̎蓦"""
"""""","""Winnow: No model built yet.""","""Iяo܂: ǂȃf܂ĂĂ܂łB"""
"""""","""Winnow\n\nAttribute weights\n\n""","""\n\nAttributed̉~n\nIяoĂB"""
"""""","""\nCumulated mistake count: ""","""\͌JEgnCumulated܂: """
"""""","""Whether to use the balanced version of the algorithm.""","""ASỸoX̂ƂĂo[Wgp܂?"""
"""""","""Promotion coefficient alpha.""","""̔iWAt@B"""
"""""","""Demotion coefficient beta.""","""iWx[^B"""
"""""","""Prediction threshold (-1 means: set to number of attributes).""","""\~(-1̎i: ̐ւ̃Zbg)B"""
"""""","""Initial value of weights/coefficients.""","""d/W̒lɓĂB"""
"""""","""Random number seed used for data shuffling (-1 means no ""","""qf[^VbtɎgpA(-1́AӖ܂B"""
"""""","""randomization).""","""׉)"""
"""""","""\tNumber of iterations.\n""","""JԂ\n\tNumber"""
"""""","""The number of iterations to be performed.""","""sׂłJԂ̐B"""
"""""","""Nearest-neighbour classifier. Uses normalized Euclidean distance to ""","""אl̍ł߂̃NVt@CAB ɂꂽ[Nbh̋gp܂B"""
"""""","""find the training instance closest to the given test instance, and predicts ""","""eXg؂āA\铖R̂Ƃ̍ł߂Ńg[jOCX^XĂB"""
"""""","""the same class as this training instance. If multiple instances have ""","""̃g[jOCX^XƓNXB ̃CX^XȂ"""
"""""","""the same (smallest) distance to the test instance, the first one found is ""","""eXgCX^Xւ̓(ł)̋ɁA11Ԗڂ͂łB"""
"""""","""used.  For more information, see \n\n""","""gpɂB ڂ́A\n\nĂB"""
"""""","""IB1: Class is numeric!""","""IB1: NX͐lł!"""
"""""","""IB1: Cannot handle string attributes!""","""IB1: XgOƂł܂!"""
"""""","""IB1 classifier""","""IB1NVt@CA"""
"""""","""Instance-based learning algorithms""","""̃x[X̊wKASY"""
"""""","""K-nearest neighbours classifier. Normalizes attributes by default. Can ""","""Kł߂אlNVt@CAB ftHgő𐳏ɂ܂B """
"""""","""select appropriate value of K based on cross-validation. Can also do ""","""Ă鍇@ɊÂK̓K؂ȒlIĂB ܂A邱Ƃł܂B"""
"""""","""distance weighting. For more information, see\n\n""","""dĂB ڂ́A\n\nĂB"""
"""""","""Aha, D., and D. Kibler (1991) ""Instance-based learning algorithms"", ""","""AD.AD.Kibler(1991)uũx[X̊wKASYvv"""
"""""","""Machine Learning, vol.6, pp. 37-66.""","""LearningAvol.6App@BHĂB 37-66."""
"""""","""Empty list""","""̃Xg"""
"""""","""Node: instance ""","""m[h: CX^X"""
"""""",""", distance """,""", """
"""""","""windowed""","""t܂B"""
"""""","""No distance weighting""","""̏dłȂ"""
"""""","""Weight by 1/distance""","""1/ɏ]d"""
"""""","""Weight by 1-distance""","""1ɏ]d"""
"""""","""The number of neighbours to use.""","""gpאl̐B"""
"""""","""Gets the maximum number of instances allowed in the training ""","""g[jOŗ̍ő吔eĂ܂B"""
"""""","""pool. The addition of new instances above this value will result ""","""܂ɂȂĂB ̒l𒴂V̓Y͌ʂƂĐł傤B"""
"""""","""in old instances being removed. A value of 0 signifies no limit ""","""Âł́A菜܂B 0̒l͌ESӖ܂B"""
"""""","""to the number of training instances.""","""g[jO̐ɁB"""
"""""","""Gets the distance weighting method used.""","""d̃\bhgp܂B"""
"""""","""Whether the mean squared error is used rather than mean ""","""2덷Ӗނgp"""
"""""","""absolute error when doing cross-validation for regression problems.""","""Â߂̌Ă鍇@Ƃ̐Ό덷B"""
"""""","""Whether hold-one-out cross-validation will be used ""","""AEgێĂĂ鍇@gp"""
"""""","""to select the best k value.""","""łǂklI邽߂ɁB"""
"""""","""Minimum value for attribute not available!""","""p\łȂ̂߂̍ŏl!"""
"""""","""Maximum value for attribute not available!""","""̂߂̗p\łȂő̒l!"""
"""""","""Whether attribute normalization is turned off.""","""퉻邩ǂ܂B"""
"""""","""This should never be reached""","""ɌĒBׂł͂܂B"""
"""""","""\tWeight neighbours by the inverse of their distance\n""","""\tWeight͂̋\n̋tŋ߂ɏZ݂܂B"""
"""""","""\tWeight neighbours by 1 - their distance\n""","""tWeight1܂łɋ߂ɏZ\--̋\n"""
"""""","""\t(use when k > 1)""","""\t(kł邱Ƃ̎gp>1)"""
"""""","""\tNumber of nearest neighbours (k) used in classification.\n""","""\nŎgp钆ōł߂אl(k)\tNumber"""
"""""","""\t(Default = 1)""","""\t(ftHg=1)"""
"""""","""-K <number of neighbors>""","""-K<אl̐>"""
"""""","""\tMinimise mean squared error rather than mean absolute\n""","""\͐\nӖނ땽2덷tMinimise܂B"""
"""""","""\terror when using -X option with numeric prediction.""","""l\ɂ-XIvVgpƂ\eB"""
"""""","""\tMaximum number of training instances maintained.\n""",""".. \nłƎ咣ꂽg[jO\tMaximumԍ"""
"""""","""\tTraining instances are dropped FIFO. (Default = no window)""","""\tTrainingCX^X͉ꂽo@łB (ftHg=܂)"""
"""""","""-W <window size>""","""-W<̃TCY>"""
"""""","""\tSelect the number of nearest neighbours between 1\n""","""\tSelect1~n̊Ԃ̍ł߂אl̐łB"""
"""""","""\tand the k value specified using hold-one-out evaluation\n""","""AEgێĂ]\ngpklw肵\tand"""
"""""","""\ton the training data (use when k > 1)""","""\g̓g[jOf[^łB(kł邱Ƃ̎gp>1)"""
"""""","""\tDon't normalize the data.\n""","""\tDonf[^𐳏ɂȂA\n"""
"""""","""IBk: No model built yet.""","""IBk: ǂȃf܂ĂĂ܂łB"""
"""""","""IB1 instance-based classifier\n""","""IB1̃x[X̃NVt@CA\n"""
"""""","""using ""","""gp"""
"""""",""" inverse-distance-weighted""",""" d݂ꂽt̋"""
"""""",""" similarity-weighted""",""" ގŁA׏dĂ܂B"""
"""""",""" nearest neighbour(s) for classification\n""",""" \n̗אl̍ł߂"""
"""""","""using a maximum of ""","""gpAő"""
"""""",""" (windowed) training instances\n""",""" (t)łB g[jO\n"""
"""""","""Data has no class attribute!""","""f[^ɂ́ANXS܂!"""
"""""","""Cross validating ""","""Lɂ邱ƂɌĂB"""
"""""","""Hold-one-out performance of ""","""AEgێĂ鐫\"""
"""""",""" neighbors """,""" אl"""
"""""","""(RMSE) = """,""""""
"""""","""(MAE) = ""","""(C) = """
"""""","""(%ERR) = ""","""(%͊ԈႦ܂) = """
"""""","""Selected k = ""","""Iꂽk="""
"""""","""Couldn't optimize by cross-validation: ""","""Ă鍇@ōœK邱ƂłȂł傤: """
"""""","""(KStarNominalAttribute.transProb) """,""""""
"""""","""stop parameter""","""p^~߂ĂB"""
"""""","""(KStarNominalAttribute.stopProbUsingBlend) """,""""""
"""""","""smallest""","""ł"""
"""""","""average""",""""""
"""""","""sphere""",""""""
"""""","""avgprob""",""""""
"""""","""minProb""",""""""
"""""","""params""",""""""
"""""","""(KStarNominalAttribute.calculateSphereSize) """,""""""
"""""","""(KStarNominalAttribute.PStar) """,""""""
"""""","""m_Train""","""m_"""
"""""","""(KStarNumericAttribute.transProb) """,""""""
"""""","""m_AttrIndex""",""""""
"""""","""m_Test""","""m_eXg"""
"""""","""sphere of influence""","""e"""
"""""","""Error: """,""": """
"""""",""" attribute class must be nominal!""",""" ̃NX͖ڏłɈႢ܂!"""
"""""","""Warning: ""","""x: """
"""""","""Ignore the instances with missing values""","""l𖳎ĂB"""
"""""","""Treat missing values as maximally different""","""ōɈقȂƂČlĂB"""
"""""","""Normalize over the attributes""","""̏ŐɂĂB"""
"""""","""Average column entropy curves""","""ςRGgs[J[u"""
"""""","""K* is an instance-based classifier, that is the class of a test ""","""K*͗̃x[X̃NVt@CAAȂ킿AeXg̃NXłB"""
"""""","""instance is based upon the class of those training instances ""","""CX^X͂̃g[jOCX^X̃NXɊÂĂ܂B"""
"""""","""similar to it, as determined by some similarity function.  It differs ""","""炩̗ގ@\͂ƓlłāAfłƂĂ܂B ͈قȂ܂B"""
"""""","""from other instance-based learners in that it uses an entropy-based ""","""̗̑̃x[X̊wKҁAgpAGgs[x[X"""
"""""","""distance function. For more information on K*, see\n\n""","""@\ĂB K*̏ڂɊւẮA\n\nĂB"""
"""""","""John, G. Cleary and Leonard, E. Trigg (1995) ""K*: An Instance- """,""""""
"""""","""based Learner Using an Entropic Distance Measure"", """,""""""
"""""","""Proceedings of the 12th International Conference on Machine """,""""""
"""""","""learning, pp. 108-114.""",""""""
"""""","""(KStar.buildClassifier) """,""""""
"""""","""(KStar.updateClassifier) """,""""""
"""""","""(KStar.distributionForInstance) """,""""""
"""""","""Computing...""","""vZc"""
"""""","""(KStar.instanceTransformationProbability) """,""""""
"""""","""Determines how missing attribute values are treated.""","""Ă鑮lǂ̂悤Ɉ邩肵܂B"""
"""""","""\tManual blend setting (default 20%)\n""","""\tManualݒ(20%ftHgƂ)\n"""
"""""","""\tEnable entropic auto-blend setting (symbolic class only)\n""","""\tEnable entropicݒ(V{bNȃNXp)\n"""
"""""","""\tSpecify the missing value treatment mode (default a)\n""","""\l[htSpecifyA(ftHgAa) \n"""
"""""","""\tValid options are: a(verage), d(elete), m(axdiff), n(ormal)\n""","""\tValidIvV͈ȉ̒ʂłB (verage)Ad(elete)Am(axdiff)An(ormal)\n"""
"""""","""-M <char>""","""-M <>"""
"""""","""The parameter for global blending. Values are restricted to [0,100].""","""O[oȍ̂߂̃p^B l0,100ɐ܂B"""
"""""","""Whether entropy-based blending is to be used.""","""Ggs[x[X͎̍gpĂ邩ǂƂł?"""
"""""","""KStar Beta Verion (0.1b).\n""","""KStarx[^Verion(0.1b)\n"""
"""""","""Copyright (c) 1995-97 by Len Trigg (trigg@cs.waikato.ac.nz).\n""",""""""
"""""","""Java port to Weka by Abdelaziz Mahoui """,""""""
"""""","""(am14@cs.waikato.ac.nz).\n\nKStar options : ""","""( am14@cs.waikato.ac.nz ).\nKStarIvV: """
"""""","""Invalid Instance Index value""","""Instance Indexl"""
"""""","""Invalid Attribute Index value""","""Attribute Indexl"""
"""""","""Invalid index value""","""̃CfbNXl"""
"""""","""in use""","""gpł"""
"""""","""Lazy Bayesian Rules Classifier. The naive Bayesian classifier provides a simple and effective approach to classifier learning, but its attribute independence assumption is often violated in the real world. Lazy Bayesian Rules selectively relaxes the independence assumption, achieving lower error rates over a range of learning tasks.  LBR defers processing to classification time, making it a highly efficient and accurate classification algorithm when small numbers of objects are to be classified.""","""ӑĂȃxCY̓NVt@CA𓝎܂B iC[uȃxCYNVt@CA̓NVt@CAwKւ̊ȒPŗLȃAv[`񋟂܂AƗ͖{̐Eł΂Έᔽ܂B ܂܂ȊwK^XN̏ŉ̌藦BāAӑĂȃxCYRules͑IIɓƗoɂ܂B LBR͕ގԂ܂ŏ܂AȂ̕ނĂ邱ƂłƂɂ\IŐmȕރASYɂāB"""
"""""","""LBR: Class is numeric!""","""LBR: NX͐lł!"""
"""""","""Can't handle numeric attributes!  Discretize the dataset prior to using Lazy Bayesian Rules or use the Filtered Classifier""","""lƂł܂! LazyxCYRulesgpOɁAf[^ZbgDiscretize邩A܂Filtered Classifiergp܂B"""
"""""","""Dataset has no class attribute""","""f[^Zbgɂ́ANXS܂B"""
"""""","""N-Fold Cross Validation: ""","""N{̌Ă鍇@: """
"""""","""Lazy Bayesian Rule: No model built yet.""","""ӑĂȃxCYK: ǂȃf܂ĂĂ܂łB"""
"""""","""=== LBR Run information ===\n\n""","""=== LBR Run===\n\n"""
"""""","""Scheme:       weka.classifiers.LBR\n""","""v: weka.classifiers.LBR\n"""
"""""","""Can't Print Lazy Bayes Rule Classifier!""","""ӑĂȃxCYKNVt@CA邱Ƃł܂!"""
"""""","""Class for performing locally weighted learning. Can do ""","""ǏIœ߂̃NX͊wKɏd݂܂B 邱Ƃł܂B"""
"""""","""classification (e.g. using naive Bayes) or regression (e.g. using ""","""(Ⴆ΁AiC[uȃxCYgp)AA(Ⴆ΁Agp"""
"""""","""linear regression). The base learner needs to implement ""","""IȕA) sx[XwK҂̕Kv"""
"""""","""WeightedInstancesHandler. For more info, see\n\n""","""WeightedInstancesHandlerB ڂɊւẮA\n\nĂB"""
"""""","""Eibe Frank, Mark Hall, and Bernhard Pfahringer (2003). ""Locally """,""""""
"""""","""Weighted Naive Bayes"". Conference on Uncertainty in AI.\n\n""",""""""
"""""","""Atkeson, C., A. Moore, and S. Schaal (1996) ""Locally weighted """,""""""
"""""","""learning"" AI Reviews.""",""""""
"""""","""\tDo not normalize numeric attributes' ""","""\tDo͐l̂̂𐳏ɂ܂B"""
"""""","""values in distance calculation.\n""","""vZ\n̒l"""
"""""","""\t(default DO normalization)""","""\t(ftHg͐퉻܂)"""
"""""","""\tSet the number of neighbours used to set""","""\tSet̓ZbĝɎgpאl̐łB"""
"""""",""" the kernel bandwidth.\n""",""" J[lш敝\n"""
"""""","""\t(default all)""","""\t(ftHgAׂ)"""
"""""","""-K <number of neighbours>""","""-K<אl̐>"""
"""""","""\tSet the weighting kernel shape to use.""","""d̃J[lgpɌ`\tSetB"""
"""""",""" 0=Linear, 1=Epanechnikov,\n""",""" 0=IłA1=EpanechnikovA\n"""
"""""","""\t2=Tricube, 3=Inverse, 4=Gaussian.\n""","""\t2=TricubeA3=tA4=Gaussian.\n"""
"""""","""\t(default 0 = Linear)""","""\t(ftHg0=I)łB"""
"""""","""-U <number of weighting method>""","""-U<d̕@̐>"""
"""""","""How many neighbours are used to determine the width of the ""","""l̗אl𑪒肷̂ɂĎgpĂ܂B"""
"""""","""weighting function (<= 0 means all neighbours).""","""@\(<=0ׂ͂Ă̗אlӖ)ɏd݂܂B"""
"""""","""Determines weighting function. [0 = Linear, 1 = Epnechnikov,""","""d݊֐肵܂B I0=1=Epnechnikov"""
"""""","""2 = Tricube, 3 = Inverse, 4 = Gaussian and 5 = Constant. ""","""2 = t̃KEX5==4TricubeA3=萔B"""
"""""","""(default 0 = Linear)].""","""(ftHg0=I)łB]."""
"""""","""Turns off normalization for attribute values in distance ""","""̑l̂߂̐퉻Itɂ܂B"""
"""""","""calculation.""","""vZB"""
"""""","""Classifier must be a ""","""NVt@CAałɈႢ܂B"""
"""""","""WeightedInstancesHandler!""",""""""
"""""","""No class attribute assigned to instances""","""CX^XɊ蓖ĂȂNXS"""
"""""","""Cannot handle string ""","""XgOƂł܂B"""
"""""","""attributes!""","""!"""
"""""","""No training instances!""","""g[jOႪ܂!"""
"""""","""Instance Distances""","""CX^X"""
"""""","""All training instances coincide with test ""","""ׂẴg[jOႪeXgƈvĂ܂B"""
"""""","""instance!""","""!"""
"""""","""using constant kernel""","""̃J[lgp܂B"""
"""""","""Instance Weights""","""CX^Xd"""
"""""","""Kept ""","""ۂ܂B"""
"""""","""Classifying test instance: ""","""eXgCX^X𕪗ނ܂: """
"""""","""Built base classifier:\n""","""g̃x[XNVt@CA: \n"""
"""""","""Locally weighted learning: No model built yet.""","""ǏIł́AwтȂAd݂܂: ǂȃf܂ĂĂ܂łB"""
"""""","""Locally weighted learning\n""","""ǏIł́A\nwԂ̂ɏd݂܂B"""
"""""","""Using classifier: ""","""NVt@CAgp܂: """
"""""","""Using linear weighting kernels\n""","""Iȏd̃J[l\ngp܂B"""
"""""","""Using epanechnikov weighting kernels\n""","""J[l\nɏd݂epanechnikovgp܂B"""
"""""","""Using tricube weighting kernels\n""","""J[l\nɏd݂u3-́vgp܂B"""
"""""","""Using inverse-distance weighting kernels\n""","""J[l\nɏd݂ȂAt̋gp܂B"""
"""""","""Using gaussian weighting kernels\n""","""KEX̏d̃J[l\ngp܂B"""
"""""","""Using constant weighting kernels\n""","""̏d̃J[l\ngp܂B"""
"""""","""Using ""","""gp"""
"""""",""" neighbours""",""" אl"""
"""""","""m_heap size is: ""","""m_R̃TCY͈ȉ̒ʂłB """
"""""","""No elements present in the heap""","""Rɂ錻݂̗vf܂B"""
"""""","""the number of elements cannot exceed the ""","""vf̐͒邱Ƃł܂B"""
"""""","""initially set maximum limit""","""߂ɁAő̌Eݒ肵ĂB"""
"""""","""new size: ""","""VTCY: """
"""""","""Class for boosting a nominal class classifier using the Adaboost ""","""Adaboostgp邱ƂŖڏ̃NXNVt@CAグ邽߂̃NX"""
"""""","""M1 method. Only nominal class problems can be tackled. Often ""","""M1\bhB ڏ̃NX肵gނƂł܂B ΂"""
"""""","""dramatically improves performance, but sometimes overfits. For more ""","""\AAXuߏ-vIɉǂ܂B ȏ"""
"""""","""Yoav Freund and Robert E. Schapire (1996). ""Experiments with a new boosting """,""""""
"""""","""algorithm"".  Proc International Conference on Machine Learning, """,""""""
"""""","""pages 148-156, Morgan Kaufmann, San Francisco.""",""""""
"""""","""Weight threshold for weight pruning.""","""d̊荞݂̂߂ɕ~ɏd݂ĂB"""
"""""","""AdaBoostM1: can't handle a numeric class!""","""AdaBoostM1: lNXƂł܂!"""
"""""","""No train instances without class missing!""","""NX̎蓦Ƃ̂ȂԃCX^X܂!"""
"""""","""\terror rate = ""","""\e="""
"""""","""  beta = """,""" x[^="""
"""""","""No model built""","""ǂȃfĂ܂łB"""
"""""","""    return """,""" ^["""
"""""","""    double [] sums = new double [""",""" dłAd= V܂Ƃ߂܂B"""
"""""","""    sums[(int) """,""" v(int) """
"""""",""".classify(i)] += ""","""..classify(i) += """
"""""","""    double maxV = sums[0];\n""",""" dmaxV=v0; \n"""
"""""","""      if (sums[j] > maxV) { maxV = sums[j]; maxI = j; }\n""",""" {maxV=j܂Ƃ߂܂; maxI=j}Ƃ(vj>maxV)łȂ\n"""
"""""","""    }\n    return (double) maxI;\n""",""" }\n^[(d)maxI; \n"""
"""""","""AdaBoostM1: No model built yet.\n""","""AdaBoostM1: ǂȃf܂. \nĂĂ܂łB"""
"""""","""AdaBoostM1: No boosting possible, one classifier used!\n""","""AdaBoostM1: \ȏグłȂA1̃NVt@CA\ngp܂B"""
"""""","""AdaBoostM1: Base classifiers and their weights: \n\n""","""AdaBoostM1: NVt@CAƔނ̑̏dbÂĂ: \n\n"""
"""""",""" Meta classifier that enhances the performance of a regression """,""" A̐\߂郁^NVt@CA"""
"""""","""base classifier. Each iteration fits a model to the residuals left ""","""NVt@CAbÂĂB eJԂ͂ƎcɃfɍ܂B"""
"""""","""by the classifier on the previous iteration. Prediction is ""","""ǑJԂł̃NVt@CAŁB \͂łB"""
"""""","""accomplished by adding the predictions of each classifier. ""","""ꂼ̃NVt@CA̗\邱ƂɂāAB܂B"""
"""""","""Reducing the shrinkage (learning rate) parameter helps prevent ""","""k(wK)p^ĥ錸"""
"""""","""overfitting and has a smoothing effect but increases the learning ""","""uߏ-vāA炩ɂȂĂʂ܂AwK𑝉܂B"""
"""""","""time.  For more information see: Friedman, J.H. (1999). Stochastic ""","""ԁB ڂɊւẮAĂ: t[h}AJ.H.(1999)B vI"""
"""""","""Gradient Boosting. Technical Report Stanford University. ""","""z̏グB Zp񍐏X^tH[hwB"""
"""""","""\tSpecify shrinkage rate. ""","""\͎ktSpecify܂B"""
"""""","""(default = 1.0, ie. no shrinkage)\n""","""(ieftHg=1.0Ak܂)\n"""
"""""","""Shrinkage rate. Smaller values help prevent overfitting and ""","""kB Ă菬lAuߏ-v̂ĥB"""
"""""","""have a smoothing effect (but increase learning time). ""","""X[WOʂĂ(wKԂ𑝉Ă)B"""
"""""","""Default = 1.0, ie. no shrinkage.""","""ieftHg=1.0Ak܂B"""
"""""","""Class must be numeric!""","""NX͐lłɈႢ܂!"""
"""""","""Sum of squared residuals ""","""悳ꂽc̍v"""
"""""","""(predicting the mean) : ""","""(ς\܂) : """
"""""","""Sum of squared residuals : ""","""悳ꂽc̍v: """
"""""","""measureNumIterations""",""""""
"""""",""" not supported (AdditiveRegression)""",""" x܂B(AdditiveRegression)"""
"""""","""Additive Regression\n\n""","""tIȕA\n\n"""
"""""","""ZeroR model\n\n""","""ZeroRf\n\n"""
"""""","""Base classifier ""","""ñNVt@CA"""
"""""",""" models generated.\n""",""" f. \n𔭐܂B"""
"""""","""\nModel number ""","""\nModelԍ"""
"""""","""Dimensionality of training and test data is reduced by ""","""g[jOƃeXgf[^̎ŁA܂B"""
"""""","""attribute selection before being passed on to a classifier.""","""NVt@CAɓnOɑIʂƍlĂB"""
"""""","""\tFull class name of attribute evaluator, followed\n""","""]ҁAĂ\n\tFullNX"""
"""""","""\teg: ""weka.attributeSelection.CfsSubsetEval -L""""","""\2Nڂ̗r: uuweka.attributeSelection.CfsSubsetEval-Lvv"""
"""""","""-E <attribute evaluator specification>""","""-E<]Ҏdl>"""
"""""","""\tFull class name of search method, followed\n""","""\bhAĂ\n\tFullNX"""
"""""","""\tby its options. (required)\n""","""\̓IvVtby܂B (Kv)łB\n"""
"""""","""\teg: ""weka.attributeSelection.BestFirst -D 1""""","""\2Nڂ̗r: uuweka.attributeSelection.BestFirst-DA1C`vAv"""
"""""","""-S <search method specification>""","""-S<\bhdl>"""
"""""","""An attribute evaluator must be specified""","""]҂w肵Ȃ΂Ȃ܂B"""
"""""",""" with the -E option.""",""" -EIvVŁB"""
"""""","""Invalid attribute evaluator specification string""","""̑]ҎdlXgO"""
"""""","""A search method must be specified""","""\bhw肵Ȃ΂Ȃ܂B"""
"""""",""" with the -S option.""",""" -SIvVŁB"""
"""""","""Invalid search specification string""","""̌dlXgO"""
"""""","""Set the attribute evaluator to use. This evaluator is used ""","""gpɑ]҂ݒ肵ĂB ̕]҂͎gpĂ܂B"""
"""""","""Set the search method. This search method is used ""","""\bhݒ肵ĂB ̌\bh͎gpĂ܂B"""
"""""","""during the attribute selection phase before the classifier is ""","""IiK̊ԁAȑOANVt@CA͂łB"""
"""""","""invoked.""","""ĂяoB"""
"""""","""No attribute evaluator has been set!""","""]҂͑SpӂłĂ܂!"""
"""""","""No search method has been set!""","""\bh͑Sݒ肳Ă܂!"""
"""""","""AttributeSelectedClassifier: No model built yet!""","""AttributeSelectedClassifier: ܂ĂȂf!S"""
"""""","""AttributeSelectedClassifier: No attribute selection possible.\n\n""","""AttributeSelectedClassifier: \ȑIȂ. \n\n"""
"""""","""\n\nHeader of reduced data:\n""","""Ăf[^\n\nHeader: \n"""
"""""","""measureNumAttributesSelected""",""""""
"""""","""measureSelectionTime""",""""""
"""""","""measureTime""",""""""
"""""",""" not supported (AttributeSelectedClassifier)""",""" x܂B(AttributeSelectedClassifier)"""
"""""","""Class for bagging a classifier to reduce variance. Can do classification ""","""ω邽߂ɃNVt@CAc܂邽߂̃NXB ނ邱Ƃł܂B"""
"""""","""and regression depending on the base learner. For more information, see\n\n""","""āAx[XwK҂ɗ镜AB ڂ́A\n\nĂB"""
"""""","""Leo Breiman (1996). ""Bagging predictors"". Machine """,""""""
"""""","""Learning, 24(2):123-140.""",""""""
"""""","""\tCalculate the out of bag error.""","""\tCalculateAobO肩B"""
"""""","""Size of each bag, as a percentage of the training set size.""","""g[jOZbgTCY̊ƂĂ̂ꂼ̃obÕTCYB"""
"""""","""Whether the out-of-bag error is calculated.""","""obOŏoĂ͌vZ܂?"""
"""""",""" not supported (Bagging)""",""" x܂B(cނ)łB"""
"""""","""Bag size needs to be 100% if ""","""obOTCÝA100%łKv܂B"""
"""""","""out-of-bag error is to be calculated!""","""obO̊Oł́A͌vZ邱Ƃł!"""
"""""","""Bagging: No model built yet.""","""c݂܂: ǂȃf܂ĂĂ܂łB"""
"""""","""Using model trees for classification""","""ނɃf؂gp܂B"""
"""""","""Class for doing classification using regression methods. Class is ""","""A@gp邱Ƃŕނ邽߂̃NXB NX͂łB"""
"""""","""binarized and one regression model is built for each class value. For more ""","""binarized̂1̉AfeKl̂߂ɒzグ܂B ȏ"""
"""""","""information, see, for example\n\n""","""AĂAႦ΁A\n\n"""
"""""","""E. Frank, Y. Wang, S. Inglis, G. Holmes, and I.H. Witten (1998) """,""""""
"""""","""""Using model trees for classification"", Machine Learning, """,""""""
"""""","""Vol.32, No.1, pp. 63-76.""",""""""
"""""","""ClassificationViaRegression can't ""","""ClassificationViaRegression͂邱Ƃł܂B"""
"""""","""handle a numeric class!""","""lNXĂ!"""
"""""","""Classification via Regression: No model built yet.""","""Regressionʂ镪: ǂȃf܂ĂĂ܂łB"""
"""""","""Classification via Regression\n\n""","""Regression\n\nʂ镪"""
"""""","""Classifier for class with index ""","""CfbNXNX̃NVt@CA"""
"""""","""\tMinimize expected misclassification cost. Default is to\n""","""\͗\zꂽތptMinimize܂B \nɂ̓ftHg܂B"""
"""""","""\treweight training instances according to costs per class""","""1NX̃RXgɏ]ăCX^XP\treweight"""
"""""","""A metaclassifier that makes its base classifier cost-sensitive. ""","""x[XNVt@CApqɂmetaclassifierB"""
"""""","""Two methods can be used to introduce cost-sensitivity: reweighting ""","""px𓱓̂2̕@gp邱Ƃł܂: u-d݂v܂B"""
"""""","""training instances according to the total cost assigned to each ""","""ꂼɊ蓖Ăꂽpɏ]g[jO"""
"""""","""class; or predicting the class with minimum expected ""","""NX; ܂́Aŏ҂ĂԂŁANX\邱ƁB"""
"""""","""misclassification cost (rather than the most likely class). ""","""ތp(ł肻ȃNXނ)B"""
"""""","""Performance can often be ""","""ptH[}X΂΂邱Ƃł܂B"""
"""""","""improved by using a Bagged classifier to improve the probability ""","""mǂ̂BaggedNVt@CAgp邱ƂɂāAサ܂B"""
"""""","""estimates of the base classifier.""","""x[XNVt@CǍςB"""
"""""","""Sets where to get the cost matrix. The two options are""","""ǂɔp}gNXɓ悤ɐݒ肷邩B 2̃IvVłB"""
"""""","""to use the supplied explicit cost matrix (the setting of the ""","""ꂽȔp}gNXgpA(Zbg܂B"""
"""""","""costMatrix property), or to load a cost matrix from a file when ""","""costMatrix̓)Aap}gNX[hɂ́At@CȂB"""
"""""","""required (this file will be loaded from the directory set by the ""","""KvłA(̃t@C̓ZbgꂽfBNg烍[hł傤B"""
"""""","""onDemandDirectory property and will be named relation_name""","""onDemandDirectory̓A֌W_OƖł傤B"""
"""""","""Sets the directory where cost files are loaded from. This option ""","""pt@C[hfBNgݒ肵܂B ̃IvV"""
"""""","""is used when the costMatrixSource is set to ""On Demand"".""","""costMatrixSourceuuvɉāvvɐݒ肳ƂAgp܂B"""
"""""","""Sets whether the minimum expected cost criteria will be used. If ""","""ŏp]\zۂɊ֌WȂAZbg͎gpł傤B if"""
"""""","""this is false, the training data will be reweighted according to the ""","""ꂪĂAg[jOf[^ɂƁAu-d݂vł傤B"""
"""""","""costs assigned to each class. If true, the minimum expected cost ""","""eNXɊ蓖ĂꂽRXgB {ɁAŏp\zȂ"""
"""""","""criteria will be used.""","""]͎gpł傤B"""
"""""","""Sets the cost matrix explicitly. This matrix is used if the ""","""炩ɔp}gNXݒ肵܂B ̃}gNX͎gpĂ܂B"""
"""""","""costMatrixSource property is set to ""Supplied"".""","""costMatrixSource̓́uuvɂ邱Ɓvɐݒ肳܂B"""
"""""","""CostSensitiveClassifier: No model built yet.""","""CostSensitiveClassifier: ǂȃf܂ĂĂ܂łB"""
"""""","""CostSensitiveClassifier using ""","""CostSensitiveClassifiergp"""
"""""","""minimized expected misclasification cost\n""","""ŏɂꂽ\zꂽmisclasificationp\n"""
"""""","""reweighted training instances\n""","""g[jO\nɁu-d݂v܂B"""
"""""",""": Character parameter identifier expected""",""": \zꂽLN^[p^ʎq"""
"""""",""": Numeric lower bound expected""",""": \zꂽlE"""
"""""",""": Upper bound is less than lower bound""",""": ͉EȉłB"""
"""""",""": Upper bound must be numeric, or 'A' or 'N'""",""": ܂́A'lA܂'A'łɈႢȂA'"""
"""""","""CVParameter ""","""CVParameter"""
"""""",""": Numeric number of steps expected""",""": \zꂽXebv̐l"""
"""""","""Setting options for ""","""IvVݒ肵܂B"""
"""""","""Cross-validated error rate: ""","""藦\ŗLɂ܂: """
"""""","""Class for performing parameter selection by cross-validation ""","""Ă鍇@Ńp^Is邽߂̃NX"""
"""""","""for any classifier. For more information, see:\n""","""ǂȃNVt@CÂ߂ɂB ڂ́A: \nĂB"""
"""""","""R. Kohavi (1995). Wrappers for Performance """,""""""
"""""","""Enhancement and Oblivious Decision Graphs. PhD """,""""""
"""""","""Thesis. Department of Computer Science, Stanford University.""",""""""
"""""","""\tNumber of folds used for cross validation (default 10).""","""Ă鍇@(ftHg10)Ɏgp܂ڂ\tNumberB"""
"""""","""\tClassifier parameter options.\n""","""\tClassifierp^IvV\n"""
"""""","""\teg: ""N 1 5 10"" Sets an optimisation parameter for the\n""","""\2Nڂ̗r: uuN1 5A10C`vA\n̍œKp^ݒ肷Av"""
"""""","""\tclassifier with name -N, with lower bound 1, upper bound\n""","""O-NAE1A\n\tclassifier"""
"""""","""\t5, and 10 optimisation steps. The upper bound may be the\n""","""t5A10~̍œK܂܂B \nł邩ȂB"""
"""""","""\tcharacter 'A' or 'I' to substitute the number of\n""","""\tcharacter'A'\n̐'I'"""
"""""","""\tattributes or instances in the training data,\n""","""\tattributesg[jOf[^̗A\n"""
"""""","""\trespectively. This parameter may be supplied more than\n""","""\trespectivelyB n~̃p^ɋ邩܂B"""
"""""","""\tonce to optimise over several classifier options\n""","""̃NVt@CAIvV\n̏tonceɍœK\"""
"""""","""\tsimultaneously.""","""\tsimultaneouslyB"""
"""""","""-P <classifier parameter>""","""-P<NVt@CAp^>"""
"""""","""N 1 5 10""","""N1 5 10"""
"""""","""CVParameterSelection: could not set options ""","""CVParameterSelection: IvVݒ肷邱Ƃł܂łB"""
"""""","""in getOptions().""","""getOptions()ŁB"""
"""""","""No training instances without ""","""P܂B"""
"""""","""missing class.""","""NX𓦂܂B"""
"""""","""Number of training instances ""","""g[jO̐"""
"""""","""smaller than number of folds.""","""܂ڂ̐菬łB"""
"""""","""Base classifier should be OptionHandler.""","""ñNVt@CAOptionHandlerłׂłB"""
"""""","""Sets the scheme parameters which are to be set ""","""ݒ肳邱Ƃłvp^ݒ肵܂B"""
"""""","""by cross-validation.\n""","""Ă鍇@\n"""
"""""","""The format for each string should be:\n""","""eXgÔ߂̌`: \nłȂ炻ł傤ɁB"""
"""""","""param_char lower_bound upper_bound number_of_steps\n""","""_param_Y_̉̃oEh㑤̃oEh_ԍ_\n𓥂݂܂B"""
"""""","""eg to search a parameter -P from 1 to 10 by increments of 1:\n""","""n1̑ɂ1?10܂ł̃p^-P: \{eg"""
"""""","""    ""P 1 10 11"" """,""" uuPA1 10 11C`vAv"""
"""""","""Get the number of folds used for cross-validation.""","""Ă鍇@ɐ܂ڂ̐gpĂB"""
"""""","""CVParameterSelection: No model built yet.""","""CVParameterSelection: ǂȃf܂ĂĂ܂łB"""
"""""","""Cross-validated Parameter selection.\n""","""\ŗLɂꂽParameterI\n"""
"""""","""Cross-validation Parameter: '-""","""Ă鍇@p^: '-"""
"""""",""" ranged from """,""" ył܂B"""
"""""",""" steps\n""",""" \n𓥂݂܂B"""
"""""","""Classifier Options: ""","""NVt@CAIvV: """
"""""","""Selected values: ""","""Iꂽl: """
"""""","""\tDesired size of ensemble.\n""","""\̓ATu\ñTCYtDesired܂B"""
"""""","""\tFactor that determines number of artificial examples to generate.\n""","""lH̗̐. \n𔭐̂肷\tFactor"""
"""""","""\tSpecified proportional to training set size.\n""","""\̓g[jOZbgTCY\nɔႵĂԂtSpecified܂B"""
"""""","""\t(default 1.0)""","""\t(ftHg1.0)"""
"""""","""the desired number of member classifiers in the Decorate ensemble. Decorate may terminate ""","""DecorateATũo[NVt@CA̕KvȐB MAI邩܂B"""
"""""","""before this size is reached (depending on the value of numIterations). ""","""ȑOÃTCYɒBĂ܂(numIterations̒lɂ)B"""
"""""","""Larger ensemble sizes usually lead to more accurate models, but increases ""","""ʏA傫ATuTCÝA葽̐mȃfɂȂāAɂȂ܂B"""
"""""","""training time and model complexity.""","""Ԃƃf̕GP܂B"""
"""""","""the maximum number of Decorate iterations to run. Each iteration generates a classifier, ""","""点DecorateJԂ̍ő吔B eJԂ̓NVt@CA𔭐܂B"""
"""""","""but does not necessarily add it to the ensemble. Decorate stops when the desired ensemble ""","""AKAATuɒǉƂ킯ł͂܂B KvȃATułƂɁA~ɏtĂB"""
"""""","""size is reached. This parameter should be greater than ""","""TCYɒBĂ܂B ̃p^́A傫ׂłB"""
"""""","""equal to the desiredSize. If the desiredSize is not being reached it may help to ""","""desiredSizeƓłB desiredSizeɒBĂȂȂA͗i邩܂B"""
"""""","""increase this value.""","""̒l𑝉ĂB"""
"""""","""determines the number of artificial examples to use during training. Specified as ""","""lH̗̐g[jO̊ԁAgp̂肵܂B w肳܂B"""
"""""","""a proportion of the training data. Higher values can increase ensemble diversity.""","""g[jOf[^̊B 荂l̓ATȗl𑝉邱Ƃł܂B"""
"""""","""DECORATE is a meta-learner for building diverse ensembles of ""","""DECORATÉA܂܂̃ATuzグ邽߂̃^wK҂łB"""
"""""","""classifiers by using specially constructed artificial training ""","""ɁAgݗĂꂽlH̃g[jOgp̂ɂNVt@CA"""
"""""","""examples. Comprehensive experiments have demonstrated that this ""","""B IȎA"""
"""""","""technique is consistently more accurate than the base classifier, Bagging and Random Forests.""","""eNjbN̓x[XNVt@CAABaggingARandom ForestsтĐmłB"""
"""""","""Decorate also obtains higher accuracy than Boosting on small training sets, and achieves ""","""MA܂Ag[jOłBoostingɂZbg荂x𓾂AB"""
"""""","""comparable performance on larger training sets. ""","""傫g[jOɊւCG鐫\̓Zbg܂B"""
"""""","""For more details see: P. Melville & R. J. Mooney. Constructing diverse classifier ensembles ""","""̑̏ڍׂɊւẮAĂ: PB rR.J.[j[B ܂܂̃NVt@CAATu\܂B"""
"""""","""using artificial training examples (IJCAI 2003).\n""","""lH̃g[jO̗(IJCAI2003)\ngp܂B"""
"""""","""P. Melville & R. J. Mooney. Creating diversity in ensembles using artificial data (submitted).""","""PB rR.J.[j[B lH̃f[^(o)gp邱ƂŃATȗl쐬邱ƁB"""
"""""","""Max number of iterations must be >= desired ensemble size!""","""Max number of iterations must be >= ATuTCY]ł܂B"""
"""""","""Initialize:\tClassifier """,""": \tClassifierĂB"""
"""""","""Iteration: ""","""JԂ: """
"""""","""\tClassifier ""","""\tClassifier"""
"""""",""" added to ensemble. Ensemble error = """,""" ATuɒǉ܂B ATu="""
"""""","""Nominal attribute has less than two distinct values!""","""ڏ̑ɁA2̈قȂl܂!"""
"""""","""Decorate can only handle numeric and nominal values.""","""MĂBĺAāAڏ̒lƂł邾łB"""
"""""","""Cumulative class membership probability is NaN!""","""ݐςĂNXimNaNł!"""
"""""","""Decorate can't handle a numeric class!""","""MAlNXƂł܂!"""
"""""","""Decorate: No model built yet.""","""M܂: ǂȃf܂ĂĂ܂łB"""
"""""","""Decorate base classifiers: \n\n""","""x[XNVt@CAMĂ: \n\n"""
"""""","""Number of classifier in the ensemble: ""","""ATũNVt@CA̐: """
"""""","""Class for running an arbitrary classifier on data that has been passed ""","""Cӂ̃NVt@CAʉ߂ꂽf[^ɎԂő邽߂̃NX"""
"""""","""through an arbitrary filter, providing the only way to access ""supervised"" ""","""Cӂ̃tB^ʂāAB̓ɃANZXւ̒񋟂́uuē܂vB"""
"""""","""filters in the Explorer. Like the classifier, the structure of the filter ""","""GNXv[[̃tB^B NVt@CAAtB^̍\̂悤"""
"""""","""is based exclusively on the training data and test instances will be processed ""","""rIȃg[jOɊÂāAf[^ƃeXgႪƂƂłB"""
"""""","""by the filter without changing its structure.""","""tB^ō\ςȂŁB"""
"""""","""\tFull class name of filter to use, followed\n""","""gptB^AĂ\n\tFullNX"""
"""""","""\tby filter options.\n""","""\tbytB^IvV\n"""
"""""","""\teg: ""weka.filters.AttributeFilter -V -R 1,2""""","""\2Nڂ̗r: uuweka.filters.AttributeFilter-V-R1A2C`vv"""
"""""","""-F <filter specification>""","""-F<tB^dl>"""
"""""","""Invalid filter specification string""","""̃tB^dlXgO"""
"""""","""The filter to be used.""","""gpׂłtB^B"""
"""""","""Filter output queue not empty!""","""łȂo̓L[tB^[ɂĂ!"""
"""""","""Filter didn't make the test instance""","""tB^̓eXgCX^X܂łB"""
"""""",""" immediately available!""",""" ɁAp\!"""
"""""","""FilteredClassifier:: ""","""FilteredClassifier:A: """
"""""",""" out: """,""" o: """
"""""","""FilteredClassifier: No model built yet.""","""FilteredClassifier: ǂȃf܂ĂĂ܂łB"""
"""""","""FilteredClassifier using ""","""FilteredClassifiergp"""
"""""",""" on data filtered through """,""" h߂ꂽf[^Ɋւ"""
"""""","""\n\nFiltered Header\n""","""\n\̓wb_[\nnFiltered܂B"""
"""""","""Implements Grading. The base classifiers are ""graded"". ""","""ts܂B x[XNVt@CÁuutvɂ܂vB """
"""""","""Seewald A.K., Fuernkranz J. (2001): An Evaluation of Grading ""","""Seewald A.K.AFuernkranz J.(2001): t̕]"""
"""""","""Classifiers, in Hoffmann F. et al. (eds.), Advances in Intelligent ""","""zt}F.̃NVt@CAA (edsB), mI̐i"""
"""""","""Data Analysis, 4th International Conference, IDA 2001, Proceedings, ""","""f[^́A4ۉcAIDA2001Ac"""
"""""","""Springer, Berlin/Heidelberg/New York/Tokyo, pp.115-124, 2001""","""Ǐo΁Ax/nCfxO/j[[N/App.115-124A2001"""
"""""","""Grading: No base schemes entered.""","""t܂: x[XvɑS܂łB"""
"""""","""Grading: No meta scheme selected.""","""t܂: v̓^I܂łB"""
"""""","""Grading: No model built yet.""","""t܂: ǂȃf܂ĂĂ܂łB"""
"""""","""Grading\n\nBase classifiers\n\n""","""\n\nBaseNVt@CA~n\nt܂B"""
"""""","""\n\nMeta classifiers\n\n""","""\n\nMetaȃNVt@CA\n\n"""
"""""","""PredConf""",""""""
"""""","""Class Attribute must not be numeric!""","""NXAttribute͐lł͂܂!"""
"""""","""Class for performing additive logistic regression. ""","""tIȃWXeBNX̕As邽߂̃NXB"""
"""""","""This class performs classification using a regression scheme as the ""","""̃NX͕Avgp镪ނs܂B"""
"""""","""base learner, and can handle multi-class problems.  For more ""","""wK҂bÂĂAāÃNXƂł܂B ȏ"""
"""""","""Friedman, J., T. Hastie and R. Tibshirani (1998) ""Additive Logistic """,""""""
"""""","""Regression: a Statistical View of Boosting"". Technical report. """,""""""
"""""","""Stanford University.\n\n""",""""""
"""""","""Can do efficient internal cross-validation to determine ""","""肷Iȓ̌Ă鍇@ł܂B"""
"""""","""appropriate number of iterations.""","""JԂ̐𓖂ĂĂB"""
"""""","""Selected ""","""I܂B"""
"""""",""" out of """,""" out of"""
"""""","""\tPercentage of weight mass to base training on.\n""","""bÂ. \nŌPďł܂\tPercentage"""
"""""","""\t(default 100, reduce to around 90 speed up)""","""\t(ftHg100A悻90ɌĂA)"""
"""""","""\tNumber of folds for internal cross-validation.\n""","""̌Ă鍇@\n̐܂ڂ\tNumber"""
"""""","""\t(default 0 -- no cross-validation)""","""\t(ftHg0--Ă鍇@܂)"""
"""""","""-F <num>""","""-F<num>"""
"""""","""\tNumber of runs for internal cross-validation.\n""","""̌Ă鍇@\n̂߂̑s\tNumber"""
"""""","""\tThreshold on the improvement of the likelihood.\n""","""\݂͌̐îƂ. \ntThreshold܂B"""
"""""","""\t(default -Double.MAX_VALUE)""","""\t(ftHg-Double.MAX_l)"""
"""""","""\tShrinkage parameter.\n""","""\tShrinkagep^\n"""
"""""","""-H <num>""","""-H<num>"""
"""""","""Weight pruning with resampling""","""u-W{ovŊ荞݂ɏd݂ĂB"""
"""""","""not allowed.""","""eĂ܂B"""
"""""","""Shrinkage parameter (use small value like 0.1 to reduce ""","""kp^A(̂0.1̂悤ɏlgpĂB"""
"""""","""overfitting).""","""uߏ-v)"""
"""""","""Threshold on improvement in likelihood.""","""݂ɂi̕~B"""
"""""","""Number of runs for internal cross-validation.""","""̌Ă鍇@̂߂̑s̐B"""
"""""","""Number of folds for internal cross-validation (default 0 ""","""̌Ă鍇@̂߂̐܂ڂ̐A(ftHg0"""
"""""","""means no cross-validation is performed).""","""ǂȌĂ鍇@sȂ̂ӖA)"""
"""""","""Whether resampling is used instead of reweighting.""","""u-W{ov́u-d݂v邱Ƃ̑Ɏgp܂?"""
"""""","""Weight threshold for weight pruning (reduce to 90 ""","""d̊荞݂̂߂ɕ~ɏd݂ĂA(90܂ŌĂB"""
"""""","""for speeding up learning process).""","""wKߒ𑁂܂)"""
"""""","""LogitBoost can't handle a numeric class!""","""LogitBoost͐lNXƂł܂!"""
"""""","""Creating copy of the training data""","""g[jOf[^̃Rs[쐬܂B"""
"""""","""Creating base classifiers""","""x[XNVt@CA쐬܂B"""
"""""","""Processing first fold.""","""ŏ̐܂ڂ܂B"""
"""""","""Best result for ""","""ł悭Ȃ܂B"""
"""""",""" iterations: """,""" JԂ: """
"""""","""Avg. log-likelihood: ""","""AvgO: """
"""""","""Training classifier ""","""g[jONVt@CA"""
"""""","""\t...for class ""","""\t.BNX̂߂"""
"""""","""No model built yet""","""܂ĂȂfS"""
"""""","""Base learner ""","""n̊wK"""
"""""",""" is not Sourcable""",""" Sourcableł͂܂B"""
"""""","""  private static double RtoP(double []R, int j) {\n""",""" lIȐÓIȓdRtoPA(dłAint j) RA{\n"""
"""""","""    double Rcenter = 0;\n""",""" dRcenter=0; \n"""
"""""","""      Rcenter += R[i];\n""",""" R Rcenter+=i; \n"""
"""""","""    Rcenter /= R.length;\n""",""" Rcenter/=R.; \n"""
"""""","""    double Rsum = 0;\n""",""" dRsum=0; \n"""
"""""","""    for (int i = 0; i < R.length; i++) {\n""",""" (int i=0; i<R.̒; i++){\n"""
"""""","""      Rsum += Math.exp(R[i] - Rcenter);\n""",""" Rsum+=Math.exp(R i--Rcenter); \n"""
"""""","""    return Math.exp(R[j]) / Rsum;\n""",""" ^[Math.exp(R j)/Rsum; \n"""
"""""","""    double [] d = distribution(i);\n""",""" dłAd=z(i); \n"""
"""""","""    double maxV = d[0];\n""",""" dmaxV=d0; \n"""
"""""","""    int maxI = 0;\n""",""" int maxI=0; \n"""
"""""","""    for (int j = 1; j < """,""" (int j=1 ; j<"""
"""""","""      if (d[j] > maxV) { maxV = d[j]; maxI = j; }\n""",""" (d j>maxV) {maxV=d j; maxI=j;}\nłB"""
"""""","""    }\n    return (double) maxI;\n  }\n\n""",""" }\n^[(d)maxI; \n} \n\n"""
"""""","""  public static double [] distribution(Object [] i) {\n""",""" ̐ÓIȃ_uAzA(Ai) {\n"""
"""""","""    double [] Fs = new double [""",""" dłAFs=V_u"""
"""""","""    double [] Fi = new double [""",""" dłAFi=V_u"""
"""""","""    double Fsum;\n""",""" dFsum; \n"""
"""""","""    Fsum = 0;\n""",""" Fsum=0; \n"""
"""""",""".classify(i); Fsum += Fi[""","""..classify(i); Fsum+=Fi"""
"""""","""    Fsum /= """,""" Fsum/="""
"""""",""" Fs[j] += (Fi[j] - Fsum) * """,""" Fs jA+=(Fi j--Fsum)*"""
"""""","""    double [] dist = new double [""",""" dłAdist=V_u"""
"""""","""    for (int j = 0; j < """,""" (int j=0 ; j<"""
"""""","""      dist[j] = RtoP(Fs, j);\n""",""" dist j=RtoP(FsAj); \n"""
"""""","""    }\n    return dist;\n""",""" }\n^[dist; \n"""
"""""","""LogitBoost: No model built yet.""","""LogitBoost: ǂȃf܂ĂĂ܂łB"""
"""""","""LogitBoost: Base classifiers and their weights: \n""","""LogitBoost: NVt@CAƔނ̑̏dbÂĂ: \n"""
"""""","""\nIteration ""","""\nIteration"""
"""""","""Number of performed iterations: ""","""sꂽJԂ̐: """
"""""","""Load cost matrix on demand""","""If}h̕הp}gNX"""
"""""","""Use explicit cost matrix""","""Ȕp}gNXgpĂB"""
"""""","""This metaclassifier makes its base classifier cost-sensitive using the ""","""metaclassifieŕAgp邱ƂŃx[XNVt@CApqɂ܂B"""
"""""","""method specified in\n\n""","""\n\nŎw肳ꂽ\bh"""
"""""","""Pedro Domingos (1999) ""MetaCost: A general method for making classifiers """,""""""
"""""","""cost-sensitive"", Proceedings of the Fifth International Conference on """,""""""
"""""","""Knowledge Discovery and Data Mining, pp 155-164.\n\n""",""""""
"""""","""This classifier should produce similar results to one created by ""","""̃NVt@CA͍쐬ꂽ1ɓľʂ𐶂ނׂłB"""
"""""","""passing the base learner to Bagging, which is in turn passed to a ""","""x[XwK҂Baggingɒʂ点܂B(Bagging͏Ԃaɓn܂)B"""
"""""","""CostSensitiveClassifier operating on minimum expected cost. The difference ""","""ŏ쓮CostSensitiveClassifierp\z܂B Ⴂ"""
"""""","""is that MetaCost produces a single cost-sensitive classifier of the ""","""apqȃNVt@CAIMetaCostYłB"""
"""""","""base learner, giving the benefits of fast classification and interpretable ""","""Ƃ̗v𕪗ނŉ𖾂ł̂ɗ^āAwK҂bÂĂB"""
"""""","""output (if the base learner itself is interpretable). This implementation  ""","""o(x[XwKҎg𖾂łȂ)B ̎"""
"""""","""uses all bagging iterations when reclassifying training data (the MetaCost ""","""g[jOf[^ɕނƂJԂc܂prAׂāA(MetaCost"""
"""""","""paper reports a marginal improvement when only those iterations containing ""","""_́ǍJԂł邱Ƃ̃}[W̉ǂ܂łƕ񍐂܂B"""
"""""","""each training instance are used in reclassifying that instance).""","""ł̃CX^XɕނȂgp邻ꂼ̃g[jOCX^X)"""
"""""","""\tNumber of bagging iterations.\n""","""c݌JԂ\n\tNumber"""
"""""","""\tFile name of a cost matrix to use. If this is not supplied,\n""","""tFilegpp}gNX\B ȂȂ\n"""
"""""","""\ta cost matrix will be loaded on demand. The name of the\n""","""\AoCoCAp}gNX͗vɉă[hł傤B \n̖O"""
"""""","""\ton-demand file is the relation name of the training data\n""","""\gvt@C̓g[jOf[^\n̊֌WłB"""
"""""","""\tplus "".cost"", and the path to the on-demand file is\n""","""\́u.cost""vtplus܂AāAṽt@Cւ̌oH\nłB"""""""
"""""","""\tspecified with the -N option.""","""\-NIvVtspecified܂B"""
"""""","""-C <cost file name>""","""-C<t@C܂>"""
"""""","""-N <directory>""","""-N<fBNg>"""
"""""","""\tThe cost matrix in Matlab single line format.""","""\tTheMatlabP`Ń}gNX܂B"""
"""""","""-cost-matrix <matrix>""","""-p}gNX<}gNX>"""
"""""","""\tSize of each bag, as a percentage of the\n""","""\n̊ƂĂ̂ꂼ̃obO\tSize"""
"""""","""\ttraining set size. (default 100)""","""\ttraining̓TCYݒ肵܂B (ftHg100)"""
"""""","""cost-matrix""","""p}gNX"""
"""""","""-cost-matrix""","""-p}gNX"""
"""""","""Gets the source location method of the cost matrix. Will ""","""p}gNX̃\[Xʒũ\bh𓾂܂B EB"""
"""""","""be one of MATRIX_ON_DEMAND or MATRIX_SUPPLIED.""","""MATRIX_ON_DEMANDMATRIX_SUPPLIED1ɂȂĂB"""
"""""","""Name of directory to search for cost files when loading ""","""[hƂAfBNg̖O̓t@C܂B"""
"""""","""costs on demand.""","""If}h̃RXgB"""
"""""","""The size of each bag, as a percentage of the training set ""","""g[jOZbg̊ƂĂ̂ꂼ̃obÕTCY"""
"""""","""size.""","""TCYB"""
"""""","""The number of bagging iterations.""","""c݌JԂ̐B"""
"""""","""A misclassification cost matrix.""","""ތ̓}gNX܂B"""
"""""","""MetaCost: No model built yet.""","""MetaCost: ǂȃf܂ĂĂ܂łB"""
"""""","""MetaCost cost sensitive classifier induction""","""MetaCost͕qȃNVt@CAU܂B"""
"""""","""\nOptions: """,""""""
"""""","""\nBase learner: ""","""\nBasewK: """
"""""","""\n\nClassifier Model\n""","""\n\nClassifier\nf܂B"""
"""""","""\n\nCost Matrix\n""","""\n~nCost}gNX\n"""
"""""","""Class for boosting a classifier using the MultiBoosting method.\n\n""","""MultiBoosting@gp邱ƂŃNVt@CAグ邽߂̃NXA\n\n"""
"""""","""MultiBoosting is an extension to the highly successful AdaBoost ""","""MultiBoosting͔ɂ܂ĂAdaBoostւ̊głB"""
"""""","""technique for forming decision committees. MultiBoosting can be ""","""ψ`邽߂̃eNjbNB MultiBoosting͂ł邱Ƃł܂B"""
"""""","""viewed as combining AdaBoost with wagging. It is able to harness ""","""AdaBoosthꓮɌƂāAȂ܂B ͔nɂł܂B"""
"""""","""both AdaBoost's high bias and variance reduction with wagging's ""","""AdaBoost̍oCAXƗhꓮɂω̗̌"""
"""""","""superior variance reduction. Using C4.5 as the base learning ""","""Dꂽω̌B x[XwKƂC4.5gp܂B"""
"""""","""algorithm, Multi-boosting is demonstrated to produce decision ""","""ASYAMulti-グ́AN߂Ɏ܂B"""
"""""","""committees with lower error than either AdaBoost or wagging ""","""AdaBoosthꓮǂ炩Ⴂ肪ψ"""
"""""","""significantly more often than the reverse over a large ""","""Ȃ肵΂΁Ȁ̋t"""
"""""","""representative cross-section of UCI data sets. It offers the ""","""UCIf[^Zbg̑\Ăfʐ}B ͒񋟂܂B"""
"""""","""further advantage over AdaBoost of suiting parallel execution. ""","""sȎsɍAdaBoost肳Ȃ闘_B"""
"""""","""Geoffrey I. Webb (2000). ""MultiBoosting: A Technique for """,""""""
"""""","""Combining Boosting and Wagging"".  Machine Learning, 40(2): """,""""""
"""""","""159-196, Kluwer Academic Publishers, Boston""",""""""
"""""","""\tNumber of sub-committees. (Default 10)""","""\tx[Xފ̏W̐ (ftHg10)"""
"""""","""Sets the (approximate) number of subcommittees.""","""ψ()̐ݒ肵܂B"""
"""""","""MultiBoostAB: No model built yet.\n""","""MultiBoostAB: ǂȃf܂. \nĂĂ܂łB"""
"""""","""MultiBoostAB: No boosting possible, one classifier used!\n""","""MultiBoostAB: \ȏグłȂA1̃NVt@CA\ngp܂B"""
"""""","""MultiBoostAB: Base classifiers and their weights: \n\n""","""MultiBoostAB: NVt@CAƔނ̑̏dbÂĂ: \n\n"""
"""""","""Weight: ""","""d: """
"""""","""not yet initialized!\n\n""","""܂A\n\nĂ܂B"""
"""""","""Number of performed Iterations: ""","""sꂽIterations̐: """
"""""","""1-against-all""","""ׂĂɑ΂1"""
"""""","""Random correction code""","""ׂ̏CR[h"""
"""""","""Exhaustive correction code""","""OIȏCR[h"""
"""""","""1-against-1""","""1ɑ΂1"""
"""""","""MultiClassClassifier: class should ""","""MultiClassClassifier: NXׂ͂łB"""
"""""","""be nominal!""","""ڏɂȂĂ!"""
"""""","""class0""",""""""
"""""","""class1""",""""""
"""""","""Unrecognized correction code type""","""FĂȂCR[h^Cv"""
"""""","""MultiClassClassifier: No model built yet.""","""MultiClassClassifier: ǂȃf܂ĂĂ܂łB"""
"""""","""MultiClassClassifier\n\n""",""""""
"""""","""\tSets the method to use. Valid values are 0 (1-against-all),\n""","""\͎gp郁\bhtSets܂B Ll0(ׂĂɑ΂1)A\nłB"""
"""""","""\t1 (random codes), 2 (exhaustive code), and 3 (1-against-1). (default 0)\n""","""\t1(ׂ̃R[h)A2(OIȃR[h)3(1ɑ΂1)B (ftHg0)\n"""
"""""","""\tSets the multiplier when using random codes. (default 2.0)""","""ׂ̃R[hgpƂA\͏搔tSets܂B (ftHg2.0)"""
"""""","""A metaclassifier for handling multi-class datasets with 2-class ""","""2NX舵̃NXf[^Zbĝ߂metaclassifier"""
"""""","""classifiers. This classifier is also capable of ""","""NVt@CAB ܂ÃNVt@CAł܂B"""
"""""","""applying error correcting output codes for increased accuracy.""","""G[CKpƁAR[h͑鐸x̂߂ɏo͂܂B"""
"""""","""Sets the width multiplier when using random codes. The number ""","""ׂ̃R[hgpƂȀ搔ݒ肵܂B """
"""""","""of codes generated will be thus number multiplied by the number of ""","""̌ʊ|ꂽłłȂ甭R[h"""
"""""","""classes.""","""NXB"""
"""""","""Sets the method to use for transforming the multi-class problem into ""","""̃NXς̂Ɏgp郁\bhݒ肵܂B"""
"""""","""several 2-class ones.""","""2NX̂́B"""
"""""","""Class for selecting a classifier from among several using cross ""","""\gp邱ƂŃNVt@CAIԂ߂̃NX"""
"""""","""validation on the training data or the performance on the ""","""g[jOf[^\̂ƂɃIȍ@"""
"""""","""training data. Performance is measured based on percent correct ""","""f[^P܂B ptH[}X̓p[ZgɊÂĐԂő肳܂B"""
"""""","""(classification) or mean-squared error (regression).""","""() ܂́A2덷(A)B"""
"""""","""\tUse cross validation for model selection using the\n""","""\ngp邱Ƃ\tUse̓fÎ߂̍@ɌĂ܂B"""
"""""","""\tgiven number of folds. (default 0, is to\n""","""\tgivenԍ̐܂ځB (ftHg0\nւ̂łB"""
"""""","""\tuse training error)""","""P\tuse)"""
"""""","""The classifiers to be chosen from.""","""I΂NVt@CAB"""
"""""","""for cross-validation.""","""Ă鍇@̂߂ɁB"""
"""""","""The number of folds used for cross-validation (if 0, ""","""܂ڂ̐Ă鍇@ɎgpA(0łȂ"""
"""""","""performance on training data will be used).""","""g[jOf[^Ɋւ鐫\gpA)"""
"""""","""Whether debug information is output to console.""","""fobO̓R\[ɏo͂܂?"""
"""""","""No base classifiers have been set!""","""x[XNVt@CA͑SpӂłĂ܂!"""
"""""","""Error rate: ""","""藦: """
"""""",""" for classifier """,""" NVt@CÂ߂"""
"""""","""MultiScheme: No model built yet.""","""MultiScheme: ǂȃf܂ĂĂ܂łB"""
"""""","""MultiScheme selection using""","""MultiSchemeIgp"""
"""""",""" cross validation error""",""" @ɌĂB"""
"""""",""" error on training data""",""" g[jOf[^ɂ"""
"""""",""" from the following:\n""",""" ȉ: \n"""
"""""","""Selected scheme: ""","""Iꂽv: """
"""""",""" Meta classifier that allows standard classification algorithms """,""" WރASYe郁^NVt@CA"""
"""""","""to be applied to ordinal class problems.  For more information see: ""","""̃NXɓKp邽߂ɁB ڂɊւẮAĂ: """
"""""","""Frank, E. and Hall, M. (in press). A simple approach to ordinal ""","""tNE.HallAM.(vXɂ)B ւ̊Ȍȉ@"""
"""""","""prediction. 12th European Conference on Machine Learning. Freiburg, ""","""\B @B̊wK\͂Ɋւ12[bp̃Rt@XB tCuN"""
"""""","""Germany.""","""hCcB"""
"""""","""OrdinalClassClassifier: class should ""","""OrdinalClassClassifier: NXׂ͂łB"""
"""""","""be declared nominal!""","""ڏłƐ錾Ă!"""
"""""","""No base classifier has been set!""","""x[XNVt@CA͑SpӂłĂ܂!"""
"""""","""-last""","""-ŏI"""
"""""","""Warning: estimated probability ""","""x: 悻m"""
"""""",""". Rounding to 0.""",""".. 0ɁA܂B"""
"""""","""OrdinalClassClassifier: No model built yet.""","""OrdinalClassClassifier: ǂȃf܂ĂĂ܂łB"""
"""""","""OrdinalClassClassifier\n\n""",""""""
"""""","""Classifier ""","""NVt@CA"""
"""""",""", using indicator values: """,""", CfBP[^gpƁAȉ͕]܂B """
"""""",""" Skipped (no training examples)\n""",""" XLbvꂽ(g[jO̗ႪȂ)\n"""
"""""","""No pruning""","""肵Ȃ"""
"""""","""Log likelihood pruning""","""O݊荞"""
"""""","""RacedIncrementalLogitBoost: Best committee on validation data\n""","""RacedIncrementalLogitBoost: @f[^\n̍łǂψ"""
"""""","""Base classifiers: \n""","""NVt@CAbÂĂ: \n"""
"""""","""\nModel ""","""\nModel"""
"""""","""\n\tClass ""","""\n\tClass"""
"""""","""Number of models: ""","""f̐: """
"""""","""Chunk size per model: ""","""1f̉TCY: """
"""""","""RacedIncrementalLogitBoost can't handle a numeric class!""","""RacedIncrementalLogitBoost͐lNXƂł܂!"""
"""""","""A base classifier has not been specified!""","""x[XNVt@CA͎w肳Ă܂!"""
"""""","""Pruning ""","""荞"""
"""""",""" committee (""",""" ψA("""
"""""","""After consuming ""","""̌"""
"""""",""" instances... (""",""" c ("""
"""""",""" instances currently in memory)""",""" ݁ÃCX^X)"""
"""""","""Chunk size ""","""TCY"""
"""""",""" models, has validation error of """,""" fāA@Ă܂B"""
"""""",""", log likelihood of """,""", ݂o^܂B"""
"""""","""Can't normalize""","""ɂ邱Ƃł܂B"""
"""""","""\tMinimum size of chunks.\n""","""\n\tMinimumTCY"""
"""""","""\t(default 500)""","""\t(ftHg500)"""
"""""","""\tMaximum size of chunks.\n""","""\n\tMaximumTCY"""
"""""","""\t(default 2000)""","""\t(ftHg2000)"""
"""""","""\tSize of validation set.\n""","""@Zbg\n\tSize"""
"""""","""\t(default 1000)""","""\t(ftHg1000)"""
"""""","""-V <num>""","""-V<num>"""
"""""","""\tCommittee pruning to perform.\n""",""".. \ns\tCommittee荞"""
"""""","""\t0=none, 1=log likelihood (default)""","""\t0=ȂɂA1=̃O(ftHg)"""
"""""","""-P <pruning type>""","""-P<荞݃^Cv>"""
"""""","""\tUse resampling for boosting.""","""グ̂߂\tUse resamplingB"""
"""""","""Classifier for incremental learning of large datasets by way of racing logit-boosted committees.""","""logitɂďグꂽψ̋ʂ傫f[^Zbg̑̏K̂߂̃NVt@CAB"""
"""""","""The minimum number of instances to train the base learner with.""","""x[XwK҂P̍ŏ̐B"""
"""""","""The maximum number of instances to train the base learner with. The chunk sizes used will start at minChunkSize and grow twice as large for as many times as they are less than or equal to the maximum size.""","""x[XwK҂P̍ő吔B TCYgṕAminChunkSizeŎn܂āA炢炪AőTCYȉł2{傫Ȃł傤B"""
"""""","""The number of instances to hold out for validation. These instances will be taken from the beginning of the stream, so learning will not start until these instances have been consumed first.""","""@̂߂ɒ񋟂̐B ̎n܂肩炱̗̂ŁA̗Ⴊŏɏ܂ŁAwK͎n܂Ȃł傤B"""
"""""","""The pruning method to use within each committee. Log likelihood pruning will discard new models if they have a negative effect on the log likelihood of the validation data.""","""eψ̒Ŏgp銠荞ݕ@B @f[^̃O݂Ń}CiX̉eƁAO݊荞݂͐V^̂Ăł傤B"""
"""""","""Force the use of resampling data rather than using the weight-handling capabilities of the base classifier. Resampling is always used if the base classifier cannot handle weighted instances.""","""x[XNVt@CȀd舵\͂gpނu-W{ovf[^̎gpĂB x[XNVt@CA׏dĂƂłȂȂAResampling͂gp܂B"""
"""""","""RacedIncrementalLogitBoost: insufficient data to build model, resorting to ZeroR:\n\n""","""RacedIncrementalLogitBoost: ZeroR: \n\nɂ悭sāAzグs\ȃf[^̓f܂B"""
"""""","""RacedIncrementalLogitBoost: no model built yet.""","""RacedIncrementalLogitBoost: ǂȃf܂ĂĂ܂łB"""
"""""","""Class for building an ensemble of randomizable base classifiers. Each ""","""_}CY\̃ATuzグ邽߂̃NX̓NVt@CAbÂ܂B ꂼ"""
"""""","""base classifiers is built using a different random number seed (but based ""","""قȂqgp̂x[XNVt@CAɌĂA(ÂĂ܂B"""
"""""","""one the same data). The final prediction is a straight average of the ""","""1̃f[^) ŏIIȗ\͂܂ȕςłB"""
"""""","""predictions generated by the individual base classifiers.""","""lɂĔ\̓NVt@CAbÂ܂B"""
"""""","""Base learner must implement Randomizable!""","""n̊wK҂RandomizablesȂ΂Ȃ܂!"""
"""""","""RandomCommittee: No model built yet.""","""RandomCommittee: ǂȃf܂ĂĂ܂łB"""
"""""","""All the base classifiers: \n\n""","""ׂẴx[XNVt@CA: \n\n"""
"""""","""A regression scheme that employs any ""","""gAv"""
"""""","""classifier on a copy of the data that has the class attribute (equal-width) ""","""NXĂf[^̃Rs[̏̃NVt@CA()łB """
"""""","""discretized. The predicted value is the expected value of the ""","""discretizedɂB \l͊ҒlłB"""
"""""","""mean class value for each discretized interval (based on the ""","""ɊÂĂꂼ̂߂̈ӒnȊKlԊudiscretizedA(B"""
"""""","""predicted probabilities for each interval).""","""eԊůԂ̗\ꂽm)"""
"""""","""Class attribute has to be numeric""","""NX͐lłȂ΂Ȃ܂B"""
"""""","""Bin Means""","""ei"""
"""""","""Discretize output queue not empty""","""łȂԂŏo̓L[Discretize܂B"""
"""""","""Discretize didn't make the test instance""","""DiscretizeAeXgCX^X܂łB"""
"""""",""" immediately available""",""" ɁAp\łB"""
"""""","""\tNumber of bins for equal-width discretization\n""","""̗U\n̗e\tNumber"""
"""""","""\t(default 10).\n""","""\t(ftHg10)\n"""
"""""","""-B <int>""","""-B<int>"""
"""""","""Number of bins for discretization.""","""Û߂̗e̐B"""
"""""","""Regression by discretization""","""Uɂ镜A"""
"""""",""": No model built yet.""",""": ǂȃf܂ĂĂ܂łB"""
"""""","""\n\nClass attribute discretized into ""","""discretized\n\nClass"""
"""""",""" values\n""",""" \n]܂B"""
"""""","""\nClassifier spec: ""","""\nClassifierdl: """
"""""","""Combines several classifiers using the stacking method. ""","""ςݏd˃\bhgp邱ƂŐl̃NVt@CA܂B"""
"""""","""Can do classification or regression. ""","""ނA邱Ƃł܂B"""
"""""","""For more information, see\n\n""","""ڂ́A\n\nĂB"""
"""""","""David H. Wolpert (1992). ""Stacked """,""""""
"""""","""generalization"". Neural Networks, 5:241-259, Pergamon Press.""",""""""
"""""","""-M <scheme specification>""","""-M <wKXL[̒`>"""
"""""","""\tSets the number of cross-validation folds.""","""Ă鍇@̐܂d˂\tSetsB"""
"""""","""\t(default: ""weka.classifiers.rules.Zero"")""","""\t(ftHg: uweka.classifiers.rules.Zero""v)"""""""
"""""","""The number of folds used for cross-validation.""","""Ă鍇@Ɏgp܂ڂ̐B"""
"""""","""Stacking: Number of cross-validation ""","""ςݏd˂܂: Ă鍇@̐"""
"""""","""folds must be positive.""","""܂ڂ͐ϋɓIłɈႢ܂B"""
"""""","""The meta classifiers to be used.""","""gpׂł郁^NVt@CAB"""
"""""","""No meta classifier has been set""","""^NVt@CA͑SpӂłĂ܂B"""
"""""","""Class attribute has to be nominal ""","""NX͖ڏłȂ΂Ȃ܂B"""
"""""","""or numeric!""","""܂́Alł!"""
"""""","""No training instances without missing ""","""g[jOႪ܂BȂ"""
"""""","""class!""","""NX!"""
"""""","""Stacking: No base schemes entered.""","""ςݏd˂܂: x[XvɑS܂łB"""
"""""","""Stacking: No meta scheme selected.""","""ςݏd˂܂: v̓^I܂łB"""
"""""","""Stacking: No model built yet.""","""ςݏd˂܂: ǂȃf܂ĂĂ܂łB"""
"""""","""Stacking\n\nBase classifiers\n\n""","""\n\nBaseNVt@CA~n\nςݏd˂܂B"""
"""""","""\n\nMeta classifier\n\n""","""\n\nMetaȃNVt@CA\n\n"""
"""""","""Meta format""","""^`"""
"""""","""Implements StackingC (more efficient version of stacking). For more ""","""StackingC(ςݏd˂Iȃo[W)s܂B ȏ"""
"""""","""Seewald A.K.: ""How to Make Stacking Better and Faster While Also Taking Care ""","""Seewald A.K.: uu܂AӂĂԁAǂςݏd˂ǂ葬܂vB"""
"""""","""of an Unknown Weakness"", in Sammut C., Hoffmann A. (eds.), Proceedings of the ""","""uv v Sammut C.̖mWeaknesszt}A.(eds܂)Ac"""
"""""","""Nineteenth International Conference on Machine Learning (ICML 2002), Morgan ""","""@B̊wK\(ICML2002)̑19ۉcA[K"""
"""""","""Kaufmann Publishers, pp.554-561, 2002.\n\n""","""Kaufmann PublishersApp.554-561A2002.\n\n"""
"""""","""Note: requires meta classifier to be a numeric prediction scheme.""",""": ^NVt@CAl\̌nł邱ƂKvłB"""
"""""","""\tFull name of meta classifier, followed by options.\n""","""tFullIvV\n郁^NVt@CA\"""
"""""","""\tMust be a numeric prediction scheme. Default: Linear Regression.""","""\tMust܂Bl\̌nɂȂĂB ftHg: IȕAB"""
"""""","""StackingC: No model built yet.""","""StackingC: ǂȃf܂ĂĂ܂łB"""
"""""","""StackingC\n\nBase classifiers\n\n""","""StackingC\An\nBaseNVt@CA~n\n"""
"""""","""\n\nMeta classifiers (one for each class)\n\n""","""n~\nMetaNVt@CA(eNX1)\n\n"""
"""""","""No range correction""","""C܂B"""
"""""","""Correct based on min/max observed""","""ϑĂԂŕɊÂďC邩A܂͍őɂĂB"""
"""""","""Entire training set""","""Ŝ̃g[jO̓Zbg܂B"""
"""""","""Single tuned fold""","""̒ꂽ܂"""
"""""","""N-Fold cross validation""","""N-܂ڂ̌Ă鍇@"""
"""""","""First class value""","""ꗬl"""
"""""","""Second class value""","""񓙒l"""
"""""","""Least frequent class value""","""łpɂłȂKl"""
"""""","""Most frequent class value""","""łpɂȊKl"""
"""""","""Class value named: ""yes"", ""pos(itive)"",""1""""","""Kl͖܂: uuu͂vvAuupos(itive)vvvAu1C`v"""
"""""","""Unrecognized evaluation mode""","""FĂȂ][h"""
"""""","""maxFM: """,""""""
"""""","""Threshold range: ""","""~͈: """
"""""","""\tThe class for which threshold is determined. Valid values are:\n""","""~肵Ă\tThẽNXB LlA: \nłB"""
"""""","""\t1, 2 (for first and second classes, respectively), 3 (for whichever\n""","""\t1A2(1ԖڂƓ񓙂̂߂ɂꂼ)A3A(ǂł\n"""
"""""","""\tclass is least frequent), and 4 (for whichever class value is most\n""","""\tclassłpɂłȂA)A4A(ǂ̊Kl̂߂ɁA啔\nł邩B"""
"""""","""\tfrequent), and 5 (for the first class named any of ""yes"",""pos(itive)""\n""","""u\tfrequent)A5A(uu͂vvɂĂƂꗬAvAv \nupos(itive܂)vB"""
"""""","""\t""1"", or method 3 if no matches). (default 5).""","""u\tvu1C`vA܂̓\bh3A}b`܂) (ftHg5)."""
"""""","""-C <integer>""","""-C<>"""
"""""","""\tNumber of folds used for cross validation. If just a\n""","""Ă鍇@Ɏgp܂ڂ\tNumberB \nłB"""
"""""","""\thold-out set is used, this determines the size of the hold-out set\n""","""Otholdݒ肵\gpĂA͋ێ҃Zbg\ñTCY肵܂B"""
"""""","""\t(default 3).""","""\t(ftHg3)B"""
"""""","""\tSets whether confidence range correction is applied. This\n""","""MpCKpĂ邩ۂɊ֌WȂA\tSets܂B \n"""
"""""","""\tcan be used to ensure the confidences range from 0 to 1.\n""","""\AtcanɎgpāA閧0?1.\n܂ŋyԂ̂ۏ؂ĂB"""
"""""","""\tUse 0 for no range correction, 1 for correction based on\n""","""CłȂtUse0~A\nɊÂĈ߂1"""
"""""","""\tthe min/max values seen during threshold selection\n""","""\tthe/͕~I\n̊ԂɌꂽlɍőɂ܂B"""
"""""","""\t(default 0).""","""\t(ftHg0)B"""
"""""","""-R <integer>""","""-R<>"""
"""""","""\tSets the evaluation mode. Use 0 for\n""","""\͕][htSets܂B \n̗pr0"""
"""""","""\tevaluation using cross-validation,\n""","""Ă鍇@gp\tevaluationA\n"""
"""""","""\t1 for evaluation using hold-out set,\n""","""]̂߂̋ێ҃Zbggp\t1A\n"""
"""""","""\tand 2 for evaluation on the\n""","""\nɂ]̂߂tand2~"""
"""""","""\ttraining data (default 1).""","""f[^(ftHg1)ttraining\B"""
"""""","""-E <integer>""","""-E<>"""
"""""","""pos(itive)""",""""""
"""""","""Only works for two-class datasets!""","""2NX̃f[^Zbĝ߂̍i!"""
"""""","""Class attribute must be nominal!""","""NX͖ڏłɈႢ܂!"""
"""""","""Couldn't find examples of both classes. No adjustment.""","""̃NXɊւ邱Ƃł܂łB ܂B"""
"""""","""pos""",""""""
"""""","""Unrecognized class value selection mode""","""FĂȂKlI[h"""
"""""","""ThresholdSelector: Using mode=""","""ThresholdSelector: [h=gp܂B"""
"""""","""ThresholdSelector: Optimizing using class ""","""ThresholdSelector: NXgp邱ƂŁAœK܂B"""
"""""","""Only 1 positive found: optimizing on training data""","""1̐܂: g[jOf[^ł́AœK܂B"""
"""""","""Number of folds for threshold selector: ""","""~ZN^̂߂̐܂ڂ̐: """
"""""","""A metaclassifier that selecting a mid-point threshold on the ""","""葽metaclassifierɂȂɑIĂa_~AI"""
"""""","""probability output by a Classifier. The midpoint ""","""Classifierɂďo͂ꂽmB _"""
"""""","""threshold is set so that a given performance measure is optimized. ""","""~ݒ肳̂ŁA^ꂽ\͍œKĂ܂B"""
"""""","""Currently this is the F-measure. Performance is measured either on ""","""݂́AF-łB ptH[}X肳AI"""
"""""","""the training data, a hold-out set or using cross-validation. In ""","""g[jOf[^Aێ҃Zbg܂͌Ă鍇@gp邱ƁB Rl"""
"""""","""addition, the probabilities returned by the base learner can ""","""YAx[XwK҂ɂĕԂꂽm͂邱Ƃł܂B"""
"""""","""have their range expanded so that the output probabilities will ""","""o͊m悤ɂ͈̔͂LĂB"""
"""""","""reside between 0 and 1 (this is useful if the scheme normally ""","""01̊ԏZłA(ꂪvłȂɗAʏ"""
"""""","""produces probabilities in a very narrow range).""","""ɋ͈͂̐Ym)"""
"""""","""Sets the class value for which the optimization is performed. ""","""œKsKlݒ肵܂B"""
"""""","""The options are: pick the first class value; pick the second ""","""IvV͈ȉ̒ʂłB ꗬlIł; 2ԖڂIłB"""
"""""","""class value; pick whichever class is least frequent; pick whichever ""","""Kl; ǂ̍łpɂłȂNXIтȂ; IAǂł"""
"""""","""class value is most frequent; pick the first class named any of ""","""Kl͍łpɂł; ꗬI"""
"""""","""""yes"",""pos(itive)"", ""1"", or the least frequent if no matches).""","""uuu͂vvvAupos(itive)vAvAuuv ŏ}b`łȂȂ悭s1C`)Av"""
"""""","""Sets the method used to determine the threshold/performance ""","""~/\肷̂Ɏgp郁\bhݒ肵܂B"""
"""""","""curve. The options are: perform optimization based on the entire ""","""ȂĂB IvV͈ȉ̒ʂłB ŜɊÂœKsĂB"""
"""""","""training set (may result in overfitting); perform an n-fold ""","""g[jO̓Zbg܂(uߏ-vƂ炷܂); sAn{"""
"""""","""cross-validation (may be time consuming); perform one fold of ""","""Ă鍇@(Ԃ邩܂); 1̐܂ڂs܂B"""
"""""","""an n-fold cross-validation (faster but likely less accurate).""","""n{̌Ă鍇@(葬AA炭قǐmłȂ)B"""
"""""","""Sets the type of prediction range correction performed. ""","""\C̃^CvsZbgB"""
"""""","""The options are: do not do any range correction; ""","""IvV͈ȉ̒ʂłB ̋CȂł; """
"""""","""expand predicted probabilities so that the minimum probability ""","""āA\ꂽmLĂAAŏ̊m"""
"""""","""observed during the optimization maps to 0, and the maximum ""","""œKn}̊ԁA0AэőɊϑ܂B"""
"""""","""maps to 1 (values outside this range are clipped to 0 and 1).""","""1(͈̔͂̊O̒l01܂Ő؂)ւ̒n}B"""
"""""","""Sets the number of folds used during full cross-validation ""","""SȌĂ鍇@̊ԂɎgp܂ڂ̐ݒ肵܂B"""
"""""","""and tuned fold evaluation. This number will be automatically ""","""āAꂽ܂ڂ̕]B ͎̐Iɂł傤B"""
"""""","""reduced if there are insufficient positive examples.""","""s\ȐϋɓIȗႪ΁A܂B"""
"""""",""" cannot be graphed""",""" Otŕ\Ƃł܂B"""
"""""","""ThresholdSelector: No model built yet.""","""ThresholdSelector: ǂȃf܂ĂĂ܂łB"""
"""""","""Threshold Selector.\n""","""~ZN^\n"""
"""""","""Classifier: ""","""NVt@CA: """
"""""","""Index of designated class: ""","""w肳ꂽNX̃CfbNX: """
"""""","""Evaluation mode: ""","""][h: """
"""""","""-fold cross-validation""","""-Ă鍇@܂d˂ĂB"""
"""""","""tuning on 1/""","""1/ɂ钲"""
"""""",""" of the data""",""" f[^ɂ"""
"""""","""tuning on the training data""","""g[jÔƂɁAf[^𒲐܂B"""
"""""","""Threshold: ""","""~: """
"""""","""Best value: ""","""łǂl: """
"""""","""Expanding range [""","""g͈"""
"""""","""] to [0, 1]\n""","""] 0A1~n"""
"""""","""Class for combining classifiers using unweighted average of ""","""gpςɁu-d݂vNVt@CA邽߂̃NX"""
"""""","""probability estimates (classification) or numeric predictions ""","""mς()l\"""
"""""","""(regression).""","""(A)."""
"""""","""Vote: No model built yet.""","""[: ǂȃf܂ĂĂ܂łB"""
"""""","""Vote combines""","""[̃RoC"""
"""""",""" the probability distributions of these base learners:\n""",""" ̃x[XwK҂̊mz: \n"""
"""""","""Class implementing a HyperPipe classifier. For each category a ""","""HyperPipeNVt@CA^NXB eJeS"""
"""""","""HyperPipe is constructed that contains all points of that category ""","""̃JeŜׂẴ|Cg܂HyperPipegݗĂ܂B"""
"""""","""(essentially records the attribute bounds observed for each category). ""","""({Iɂ́AeJeSɊւĊϑꂽ̈L^܂B)"""
"""""","""Test instances are classified according to the category that ""most ""","""eXgႪJeSɂ^Ȃ番ނĂAuu啔v"""
"""""","""contains the instance"". ""","""uCX^X܂łvAv """
"""""","""Does not handle numeric class, or missing values in test cases. Extremely ""","""lNXA܂̓eXgP[Xɂ錇l܂B """
"""""","""simple algorithm, but has the advantage of being extremely fast, and ""","""ȒPȃASYAɑ݂̗_Ă܂B"""
"""""","""works quite well when you have ""smegloads"" of attributes.""","""Ȃɑ́usmegloads""vƂAS悭Ă܂B"""""""
"""""","""Cannot process string attributes!""","""XgO邱Ƃł܂!"""
"""""","""HyperPipes: class attribute needs to be nominal!""","""HyperPipes: ڏɂȂNX̕Kv!"""
"""""","""HyperPipes classifier""","""HyperPipesNVt@CA"""
"""""","""HyperPipes classifier\n""","""HyperPipesNVt@CA\n"""
"""""","""HyperPipe for class: ""","""NX̂߂HyperPipe: """
"""""","""Classification by voting feature intervals. Intervals are ""","""Ԋuɂē[̂ɂ镪ށB Ԋu͂łB"""
"""""","""constucted around each class for each attribute (""","""ê߂ɊeNX̎constuctedA("""
"""""","""basically discretization). Class counts are ""","""{IɗU) NXJEg͂łB"""
"""""","""recorded for each interval on each attribute. Classification is by ""","""e̊eԊůԁAL^܂B ނ͂łB"""
"""""","""voting. For more info see Demiroz, G. and Guvenir, A. (1997) ""","""[B ڂɊւẮADemirozG.GuvenirAAĂB(1997) """
"""""","""""Classification by voting feature intervals"", ECML-97.\n\n""","""ECML-97uuԊuɂē[̂ɂ镪ށvvA\n\n"""
"""""","""Have added a simple attribute weighting scheme. Higher weight is ""","""̌nɏd݂ȒPȑ܂B 荂d͂łB"""
"""""","""assigned to more confident intervals, where confidence is a function ""","""莩MԊu܂Ŋ蓖Ă܂Bł́AMp͋@\łB"""
"""""","""of entropy:\nweight (att_i) = (entropy of class distrib att_i / ""","""Ggs[: \nweight(att_i)=A(NXdistrib att_i/̃Ggs["""
"""""","""max uncertainty)^-bias""","""ő̕sm) ^oCAX"""
"""""","""\tDon't weight voting intervals by confidence""","""\tDon͐Mp[̊Ԋuɏd݂܂B"""
"""""","""\tSet exponential bias towards confident intervals\n""","""MԊu\nɌ\tSet̎w̃oCAX"""
"""""","""\t(default = 1.0)""","""\t(ftHg=1.0)"""
"""""","""-B <bias>""","""-B<oCAX>"""
"""""","""Weight feature intervals by confidence""","""MpԊuɏd݂ĂB"""
"""""","""Strength of bias towards more confident features""","""莩MɌoCAX̋"""
"""""","""No class attribute assigned""","""蓖ĂȂNXS"""
"""""","""VFI: class attribute needs to be nominal!""","""VFI: ڏɂȂNX̕Kv!"""
"""""","""FVI: Classifier not built yet!""","""FVI: NVt@CA͂܂ĂĂ܂ł!"""
"""""","""Voting feature intervals classifier\n""","""ԊuNVt@CA\nł̂ɓ[܂B"""
"""""","""This shouldn't happen""","""͋Nׂł͂܂B"""
"""""","""\tFull class name of classifier to include, followed\n""","""܂łNVt@CAAĂ\n\tFullNX"""
"""""","""\tby scheme options. May be specified multiple times.\n""","""\tby̌nIvVB w肳ꂽ{\nł邩ȂB"""
"""""","""\t(default: ""weka.classifiers.rules.ZeroR"")""","""\t(ftHg: uweka.classifiers.rules.ZeroR""v)"""""""
"""""","""-B <classifier specification>""","""-B<NVt@CAdl>"""
"""""","""The base classifiers to be used.""","""gpׂłx[XNVt@CAB"""
"""""","""\tRandom number seed.\n""","""\tRandom̎q\n"""
"""""","""This class implements a single conjunctive rule learner that can predict ""","""̃NX͂ꂪ\邱ƂłƐg̐ڑ̋KwK҂܂B"""
"""""","""for numeric and nominal class labels.\n\n""","""ĺAāAڏ̃NXx\n\n"""
"""""","""A rule consists of antecedents ""AND""ed together and the consequent (class value) ""","""KOႩ琬AuAND""Auꏏɋƌʁv(Kl) """""""
"""""","""for the classification/regression.  In this case, the consequent is the ""","""/Â߂ɁB ̏ꍇAʂ͂łB"""
"""""","""distribution of the available classes (or mean for a numeric value) in the dataset. ""","""f[^ZbgɂAp\ȃNX(܂́Al̂߂̕)̕zB"""
"""""","""If the test instance is not covered by this rule, then it's predicted ""","""eXgႪ̋KŃJo[ĂȂȂA͗\܂B"""
"""""","""using the default class distributions/value of the data not covered by the ""","""Jo[Ȃf[^̃ftHgNXz/lgp邱ƁB"""
"""""","""rule in the training data.""","""g[jOf[^œĂB"""
"""""","""This learner selects an antecedent by computing the Information Gain of each ""","""̊wK҂́Aꂼ̏GainvZ邱ƂɂāAOI܂B"""
"""""","""antecendent and prunes the generated rule using Reduced Error Prunning (REP) ""","""Reduced Error Prunninggp锭antecendentƃv[(bv) """
"""""","""or simple pre-pruning based on the number of antecedents.\n\n""","""܂́AO\n̐ɊÂȒPȃv荞\n"""
"""""","""For classification, the Information of one antecedent is the weighted average of ""","""ނ̂߂ɁA1̑OɊւ͉dςłB"""
"""""","""the entropies of both the data covered and not covered by the rule.\n""","""̃f[^̃Ggs[K̓Jo[āAJo[ȂA\n"""
"""""","""For regression, the Information is the weighted average of the mean-squared errors ""","""Â߂ɁA͕2덷̉dςłB"""
"""""","""of both the data covered and not covered by the rule.\n\n""","""̃f[^AāAK. \n\n͕Ă܂B"""
"""""","""In pruning, weighted average of the accuracy rates on the pruning data is used ""","""荞݊荞݃f[^̐x[g̉dς͎gpĂ܂B"""
"""""","""for classification while the weighted average of the mean-squared errors ""","""2덷̉dςłԂ̕ނ̂߂"""
"""""","""on the pruning data is used for regression.\n\n""","""荞݂̂ƂɁAf[^͕A\n\nɎgp܂B"""
"""""","""att = value""","""att=l"""
"""""","""\tSet if NOT uses randomization\n""","""\͗pr׉\nłȂȂtSet܂B"""
"""""","""\t(default:use randomization)""","""\t(ftHgƂĂ: ׉gpĂ)"""
"""""","""\tSet whether consider the exclusive\n""","""\tSetArI\nłƍlĂB"""
"""""","""\texpressions for nominal attributes\n""","""ڏ̑\n\texpressions"""
"""""","""\t(default false)""","""\t(UŃftHgƂ܂)"""
"""""","""-M <min. weights>""","""-Md݂<>"""
"""""","""\tSet number of antecedents for pre-pruning\n""","""\nv肷邽߂̑O\tSetԍ"""
"""""","""\tif -1, then REP is used\n""","""\tif-1AREP͒Â\nłB"""
"""""","""\t(default -1)""","""\t(ftHg-1)"""
"""""","""-P <number of antecedents>""","""-P<O̐>"""
"""""","""\tSet the seed of randomization\n""","""\tSet͖׉\n̎qłB"""
"""""","""Set whether to consider exclusive expressions for nominal ""","""ZbgArIȕ\lAڏ"""
"""""","""attribute splits.""","""ҊʂƍlĂB"""
"""""","""Set the number of antecedents allowed in the rule if ""","""KŋeꂽO̐ݒ肵ĂB"""
"""""","""pre-pruning is used.  If this value is other than -1, then ""","""v荞݂͎gpĂ܂B -1A̎āA̒lȂ"""
"""""","""pre-pruning will be used, otherwise the rule uses reduced-error ""","""v荞݂͎gpł傤BȂ΁AK͌Ăgp܂B"""
"""""","""pruning.""","""肵܂B"""
"""""","""No training data!""","""g[jOf[^܂!"""
"""""","""Not training data without missing class values.""","""ĂKlȂŃf[^P܂B"""
"""""","""Not enough data for REP.""","""REPɏ\ȃf[^łȂB"""
"""""","""Testing instance is NULL!""","""eXgCX^XNULLł!"""
"""""","""\n\nSingle conjunctive rule learner:\n""","""n~\nSingle̐ڑ̋KwK: \n"""
"""""","""\n\nClass distributions:\nCovered by the rule:\n""","""K: \n\n\nClassz: \nCovered"""
"""""","""\n\nNot covered by the rule:\n""","""Kŕꂽ\n\nNot: \n"""
"""""","""Class for building and using a simple decision table majority ""","""^Ȍ\啔zグāAgp邽߂̃NX"""
"""""","""classifier. For more information see: \n\n""","""NVt@CAB ڂɊւẮAĂ: \n\n"""
"""""","""Kohavi R. (1995). ""The Power of Decision Tables."" In Proc """,""""""
"""""","""European Conference on Machine Learning.""",""""""
"""""","""Node: ""","""m[h: """
"""""","""index out of range (removeLinkAt)""","""͈͂AĂB(removeLinkAt)"""
"""""","""List is empty (getLinkAt)""","""Xg͋łB(getLinkAt)"""
"""""","""index out of range (getLinkAt)""","""͈͂AĂB(getLinkAt)"""
"""""","""merit""",""""""
"""""","""Hash val: ""","""val_sĂ: """
"""""","""left out""","""Ȃ܂B"""
"""""","""Accuracy of initial subset: ""","""̕W̐x: """
"""""","""evaluating: ""","""]܂: """
"""""","""new best feature set: ""","""Vłǂ̓Zbg܂: """
"""""","""\tNumber of fully expanded non improving subsets to consider\n""","""\nl銮SɊgĂ㕔W\tNumber"""
"""""","""\tbefore terminating a best first search.\n""","""łǂŏ̌\nI\tbefore"""
"""""","""\tUse in conjunction with -B. (Default = 5)""","""-BɊ֘A\tUseB (ftHg=5)"""
"""""","""-S <number of non improving nodes>""","""-S<m[h̐>"""
"""""","""\tUse cross validation to evaluate features.\n""","""\tUséA\n]邽߂ɍ@ɌĂ܂B"""
"""""","""\tUse number of folds = 1 for leave one out CV.\n""","""tUsetԂCV\n̋x1̂߂̐܂=1\"""
"""""","""\t(Default = leave one out CV)""","""\t(CṼftHg=x1)"""
"""""","""\tUse nearest neighbour instead of global table majority.\n""","""O[oȃe[u啔\n̑ɗאl̍ł߂\tUse"""
"""""","""\tDisplay decision table rules.\n""","""\tDisplay\K\n"""
"""""","""Sets the number of folds for cross validation (1 = leave one out).""","""Ă鍇@(1=̋x1OɂԂ)ɐ܂ڂ̐ݒ肵܂B"""
"""""","""Sets the number of non improving decision tables to consider ""","""㌈\̐ɍl悤ɐݒ肵܂B"""
"""""","""before abandoning the search.""","""̂ĂOɁB"""
"""""","""Sets whether IBk should be used instead of the majority class.""","""IBk命̃NX̑Ɏgpׂł邩ۂɊ֌WȂAZbg܂B"""
"""""","""Sets whether rules are to be printed.""","""KƂł邩ۂɊ֌WȂAZbg܂B"""
"""""","""No training instances without missing class!""","""ĂNXȂ΃g[jOႪ܂!"""
"""""","""The class col: ""","""NX: """
"""""",""" not supported (DecisionTable)""",""" x܂B(DecisionTable)"""
"""""","""Decision Table: No model built yet.""","""\: ǂȃf܂ĂĂ܂łB"""
"""""","""Decision Table:""","""\:"""
"""""","""\n\nNumber of training instances: ""","""g[jO\n\nNumber: """
"""""","""Non matches covered by IB1.\n""","""IB1\nŕꂽ}b`"""
"""""","""Non matches covered by Majority class.\n""","""MajoritỹNX\nŕꂽ}b`"""
"""""","""Best first search for feature set,\nterminated after ""","""Zbg̍łǂŏ̌Anterminatedꂽ\"""
"""""",""" non improving subsets.\n""",""" 㕔W\n"""
"""""","""Evaluation (for feature selection): CV ""","""](Î߂): CV"""
"""""",""" fold) """,""" ܂) """
"""""","""(leave one out) ""","""(1Ȃ܂) """
"""""","""\nFeature set: ""","""\nFeature̓Zbg܂: """
"""""","""Fast Effective Rule Induction""","""LȋKU"""
"""""","""ab+bcd+defg""","""+bcd+defg"""
"""""","""This class implements a propositional rule learner, Repeated Incremental ""","""̃NX͒Ă̋KwKҁARepeated Incremental܂B"""
"""""","""Pruning to Produce Error Reduction (RIPPER), which was proposed by William ""","""Produce Error Reduction(RIPPER)ւ̊荞݁B(Produce Error Reduction̓EBAɂĒĂ܂)B"""
"""""","""W. Cohen as an optimized version of IREP. \n\n""","""WB IREP̍œKꂽo[WƂẴR[GB \n\n"""
"""""","""The algorithm is briefly described as follows: \n\n""","""ASY͈ȉ̒ʂȌɐ܂: \n\n"""
"""""","""Initialize RS = {}, and for each class from the less prevalent one to ""","""RS={}āAقǈʓIłȂ̂̊eNX̂߂"""
"""""","""the more frequent one, DO: \n\n""","""葽A1ɂ悭sāAȉ܂B \n\n"""
"""""","""1. Building stage:\nRepeat 1.1 and 1.2 until the descrition length (DL) ""","""1. ĂāAnRepeat1.1~1.2descrition̒܂ňȉ㉉܂B(dl) """
"""""","""of the ruleset and examples is 64 bits greater than the smallest DL ""","""rulesetƗ͍łDL64rbg΂炵łB"""
"""""","""met so far, or there are no positive examples, or the error rate >= 50%. ""","""藦>ϋɓIȗA܂=50%܂ł̂ƂA܂͂܂B"""
"""""","""1.1. Grow phase:\n""","""1.1. tF[Y: \nĂĂB"""
"""""","""Grow one rule by greedily adding antecedents (or conditions) to ""","""×~ɁAO(܂́A)̂ɂ1̋KĂ܂B"""
"""""","""the rule until the rule is perfect (i.e. 100% accurate).  The ""","""K܂ł̋K͊Sł(Ȃ킿A100%m)B The"""
"""""","""procedure tries every possible value of each attribute and selects ""","""ꂼ̂\ȒlʂƍlāAI菇gC"""
"""""","""the condition with highest information gain: p(log(p/t)-log(P/T)).""","""ł񗘓: p(O(p/t)O(P/T))B"""
"""""","""1.2. Prune phase:\n""","""1.2. v[̃tF[Y: \n"""
"""""","""Incrementally prune each rule and allow the pruning of any ""","""eK𑝉ę肵ĂAāÅ荞݂eĂB"""
"""""","""final sequences of the antecedents;""","""O̍ŏIIȌn;"""
"""""","""The pruning metric is (p-n)/(p+n) -- but it's actually ""","""肵āA[g@ł邱ƂA(p-n)/(p+n)łA͎ۂ+łB"""
"""""","""2p/(p+n) -1, so in this implementation we simply use p/(p+n) ""","""2p/(p+n)-1̎ɁAPp/gpāA(p+n) """
"""""","""(actually (p+1)/(p+n+2), thus if p+n is 0, it's 0.5).\n\n""","""(ۂ(p+1)/(p+n+2)ǍʁAp+n0łȂA0.5ł). \n\n"""
"""""","""2. Optimization stage:\n after generating the initial ruleset {Ri}, ""","""2. œKXe[W: ruleset{Ri}𔭐\n"""
"""""","""generate and prune two variants of each rule Ri from randomized data ""","""_}CYꂽf[^炻ꂼ̋KRi2ٌ̈`𔭐āA肵ĂB"""
"""""","""using procedure 1.1 and 1.2. But one variant is generated from an ""","""菇1.11.2p܂B ٌ`1"""
"""""","""empty rule while the other is generated by greedily adding antecedents ""","""Е×~ɑO邱ƂɂĔĂԁAKɂĂB"""
"""""","""to the original rule. Moreover, the pruning metric used here is ""","""IWiɁAĂB ̂A荞݁A[g@AÂłAɁA܂B"""
"""""","""Then the smallest possible DL for each variant and the original rule ""","""ɁAeٌ`̂߂̍ł\DLƃIWi̋K"""
"""""","""is computed.  The variant with the minimal DL is selected as the final ""","""vZ܂B ŏʂDLٌ`͌ƂđI肳܂B"""
"""""","""representative of Ri in the ruleset.""","""rulesetRi\܂B"""
"""""","""After all the rules in {Ri} have been examined and if there are still ""","""ǁAׂāA܂΁A{Ri}̋K͂łB"""
"""""","""residual positives, more rules are generated based on the residual ""","""c̐łA葽̋KcɊÂĔ܂B"""
"""""","""positives using Building Stage again. \n""","""ĂуrStagegp鐳B \n"""
"""""","""3. Delete the rules from the ruleset that would increase the DL of the ""","""3. ꂪDL𑝉rulesetK폜܂B"""
"""""","""whole ruleset if it were in it. and add resultant ruleset to RS. \n""","""ŜrulesetłȂ炻ɂ܂B. RSɌʂrulesetĂB \n"""
"""""","""ENDDO\n\n""",""""""
"""""","""Note that there seem to be 2 bugs in the original ripper program that would ""","""2̃oOIWî郊bp[vOł悤Ɏv̂ɒӂĂB"""
"""""","""affect the ruleset size and accuracy slightly.  This implementation avoids ""","""rulesetTCYƐxɂ킸ɉeĂB ͔̎܂B"""
"""""","""these bugs and thus is a little bit different from Cohen's original ""","""́A}ŋāǍʁAR[G̃IWiƂق̏قȂĂ܂B"""
"""""","""implementation. Even after fixing the bugs, since the order of classes with ""","""B ɁANX̒ȗ̃oOC܂B"""
"""""","""the same frequency is not defined in ripper, there still seems to be ""","""px͒Ńbp[`ȂŁA悤ɂ܂vĂ邱ƂłB"""
"""""","""some trivial difference between this implementation and the original ripper, ""","""̎ƃIWĩbp[̉炩ׂ̍ȈႢ"""
"""""","""especially for audiology data in UCI repository, where there are lots of ""","""UCIqɂ̒owf[^BɁA܂B"""
"""""","""classes of few instances.\n\n""","""킸ȃCX^X\n\ñNX"""
"""""","""Details please see ""Fast Effective Rule Induction"", William W. Cohen, ""","""EBAEW.R[GAڍׂuuLȋKUvvĂB"""
"""""","""'Machine Learning: Proceedings of the Twelfth International Conference'""","""'@B̊wK\:' '12ۉc̋c'"""
"""""","""(ML95). \n\n""","""(ML95B) \n\n"""
"""""","""PS.  We have compared this implementation with the original ripper ""","""PS̓IWĩbp[Ƃׂ̎܂B"""
"""""","""implementation in aspects of accuracy, ruleset size and running time ""","""x̋ǖʂł̎ArulesetTCYAюs"""
"""""","""on both artificial data ""ab+bcd+defg"" and UCI datasets.  In all these ""","""lH̃f[^uu+bcd+defgvvUCIf[^Zbg̗ɊւāB """
"""""","""aspects it seems to be quite comparable to the original ripper ""","""ꂪIWĩbp[ɂȂCGĂ邽߂Ɏvǖ"""
"""""","""implementation.  However, we didn't consider memory consumption ""","""B ȂÁAłƍl܂łB"""
"""""","""optimization in this implementation.\n\n""","""̍œKA\n\n"""
"""""","""\tSet number of folds for REP\n""","""REP\n̐܂ڂ\tSetԍ"""
"""""","""\tSet the number of runs of\n""","""\tSet\n̑s̐łB"""
"""""","""\toptimizations. (Default: 2)""","""\toptimizationsB (ftHg: 2)"""
"""""","""-O <number of runs>""","""-O<s̐>"""
"""""","""\tSet whether turn on the\n""","""\tSetA\nĂB"""
"""""","""\tdebug mode (Default: false)""","""\tdebug[h(ftHgƂĂ: Ă)łB"""
"""""","""\tThe seed of randomization\n""","""tThe׉\n\"""
"""""","""\t(Default: 1)""","""\t(ftHg: 1)"""
"""""","""Whether NOT check the error rate>=0.5\n""","""Whether NOT check the error rate>=0.5~n"""
"""""","""\tin stopping criteria ""","""\XY~]"""
"""""","""\t(default: check)""","""\t(ftHgƂĂ: `FbNĂ)"""
"""""","""Whether NOT use pruning\n""","""荞\ngp܂B"""
"""""","""\t(default: use pruning)""","""\t(ftHgƂĂ: 荞݂gpĂ)"""
"""""",""" not supported (RIPPER)""",""" x܂B(bp[)"""
"""""","""The number of optimization runs.""","""œK̐͑܂B"""
"""""","""Whether check for error rate >= 1/2 is included""","""Whether check for error rate >= 1/2͊܂܂Ă܂B"""
"""""",""" in stopping criterion.""",""" ~]ŁB"""
"""""",""" Consequent not set yet.""",""" ʂ͂܂ZbgĂ܂łB"""
"""""","""\nOne condition: size = ""","""\nOneƂ܂: TCY="""
"""""","""Test of \'""","""'\̃eXg'"""
"""""","""\': infoGain = ""","""\': infoGain="""
"""""",""" | Accuracy = """,""" | x="""
"""""",""" def. accuracy: """,""" defx: """
"""""","""Pruning with ""","""荞"""
"""""",""" positive data out of """,""" ϋɓIȃf[^"""
"""""","""(useAccuray? ""","""(useAccuray?"""
"""""",""" Cannot handle string attributes!""",""" XgOƂł܂!"""
"""""","""Number of all possible conditions = ""","""ׂẲ\ȏ=̐"""
"""""",""" Unable to randomize the class orders.""",""" NX߂_}CY邱Ƃł܂B"""
"""""",""" No instances with a class value!""",""" KlCX^X܂!"""
"""""","""Sorted classes:""","""ނꂽNX:"""
"""""",""" has """,""" Ă܂B"""
"""""",""" instances.""",""" CX^XB"""
"""""","""\n\nClass ""","""\n\nClass"""
"""""","""instances\n""","""\n"""
"""""","""Should never happen: ""","""ċNׂł͂܂: """
"""""","""defDL NaN or infinite!""","""defDL NaN!"""
"""""","""The default DL = ""","""ftHgDL="""
"""""","""Should never happen!""","""ċNׂł͂܂!"""
"""""","""\n*** Building stage ***""","""\n***rXe[W***"""
"""""","""\nGrowing a rule ...""","""KcnGrowing\"""
"""""","""One rule found before pruning:""","""肵ĂȑO킩1̋K:"""
"""""","""\nPruning the rule ...""","""KcnPruning\"""
"""""","""One rule found after pruning:""","""荞݂̌Ɍꂽ1̋K:"""
"""""","""\nNo pruning: growing a rule ...""","""\nNo荞: KĂ܂c"""
"""""","""No pruning: one rule found:\n""","""肵Ȃ: ꂽ1̋K: \n"""
"""""","""Should never happen: dl in ""","""ċNׂł͂܂: dl"""
"""""","""building stage NaN or infinite!""","""Xe[WNaN𑢂邱!"""
"""""","""Before optimization(""","""œK̑OA("""
"""""","""): the dl = ""","""): dl="""
"""""","""One rule added: has positive? ""","""1̋K܂: ϋɓIɁAĂ܂?"""
"""""","""Quit rule""","""K߂ĂB"""
"""""","""\n*** Optimization: run #""","""\n***œK: s#"""
"""""","""\nRule #""","""\nRule#"""
"""""","""| isResidual?""",""""""
"""""","""| data size: ""","""| f[^TCY: """
"""""",""" a new rule ...""",""" VKc"""
"""""","""\nNew rule found: ""","""\nNeẃAȉݗ悤ɍٌ܂B """
"""""",""" Replace ...""",""" ւ܂B"""
"""""","""\nGrowing and pruning""","""\nGrowingƊ荞"""
"""""",""" Revision ...""",""" c"""
"""""","""Replace rule covers: ""","""KJo[ւĂ: """
"""""","""\nReplace: """,""""""
"""""","""Should never happen: repDL""","""ċNׂł͂܂: repDL"""
"""""","""Revision: """,""": """
"""""","""Should never happen: revDL""","""ċNׂł͂܂: revDL"""
"""""","""Should never happen: oldDL""","""ċNׂł͂܂: oldDL"""
"""""","""in optmz. stage NaN or ""","""܂optmzXe[WNaNB"""
"""""","""infinite!""","""!"""
"""""","""Old rule: ""","""ÂK: """
"""""","""\nrepDL: """,""""""
"""""","""\nrevDL: """,""""""
"""""","""\noldDL: """,""""""
"""""","""After optimization: the dl""","""œǨ: dl"""
"""""",""" | best: """,""" | őP: """
"""""","""The rule covers: ""","""KJo[: """
"""""",""" | neg = """,""" | neg="""
"""""","""\nThe rule doesn't cover: ""","""nThe\͈ȉJo[Ă܂B """
"""""",""" | pos = """,""" | pos="""
"""""","""\nRuleset so far: ""","""܂ł̂Ƃ\nRuleset: """
"""""","""\nDeleting rules to decrease""","""邽߂ɋKnDeleting\"""
"""""",""" DL of the whole ruleset ...""",""" ŜrulesetDLc"""
"""""",""" rules are deleted""",""" K͍폜܂B"""
"""""",""" after DL reduction procedure""",""" DL菇̌"""
"""""","""\nFinal ruleset: """,""""""
"""""","""DL too large: ""","""DLA傫߂܂: """
"""""","""Too few positives.""","""܂ɂ킸ȐB"""
"""""","""Error too large: ""","""A傫߂܂: """
"""""","""Continue.""","""ĂB"""
"""""","""JRIP: No model built yet.""","""JRIP: ǂȃf܂ĂĂ܂łB"""
"""""","""JRIP rules:\n""","""JRIPK: \n"""
"""""","""Inside m_Ruleset""","""m_Ruleset̒"""
"""""","""Generates a decision list for regression problems using ""","""gp邱Ƃɂ镜Â߂̌胊Xg𔭐܂B"""
"""""","""separate-and-conquer. In each iteration it builds a ""","""؂藣ĂAāAĂB eJԂł́AaĂ܂B"""
"""""","""model tree using M5 and makes the ""best"" ""","""M5gp邱ƂŖ؂fāAuuőPvv܂B"""
"""""","""leaf into a rule. Reference:\n\n""","""Kւ̗tB Q: \n\n"""
"""""","""M. Hall, G. Holmes, E. Frank (1999).  ""Generating Rule Sets """,""""""
"""""","""from Model Trees"". Proceedings of the Twelfth Australian Joint ""","""""
"""""","""Conference on Artificial Intelligence, Sydney, Australia. """,""""""
"""""","""Springer-Verlag, pp. 1-12.""",""""""
"""""","""Instance-Based learning : Nearest Neighbor With Generalization""","""x[X̗̊wK: ʉ̗אl̍ł߂"""
"""""","""Nearest Neighbor With Generalization""","""ʉ̗אl̍ł߂"""
"""""","""Nearest-neighbor-like algorithm using non-nested generalized exemplars ""","""qɂꂽʉꂽ{gpאl̍ł悤ȃASY"""
"""""","""(which are hyperrectangles that can be viewed as if-then rules). For more ""","""-āA(邱Ƃłu-`vǂ̂ł邩K) ȏ"""
"""""","""information, see \n\n""","""A\n\nĂB"""
"""""","""Brent Martin, (1995) ""Instance-Based learning : Nearest Neighbor With """,""""""
"""""","""Generalization"", Master Thesis, University of Waikato, Hamilton, New """,""""""
"""""","""Zealand\n\n""",""""""
"""""","""Sylvain Roy (2002) ""Nearest Neighbor With Generalization"",""",""""""
"""""","""Unpublished, University of Canterbury, Christchurch, New Zealand\n\n""","""\n\n"""
"""""","""Exemplar.generalise : Incompatible instance's class.""","""Exemplar.generalise: ȂCX^X̃NXB"""
"""""","""Exemplar.generalise : Generalisation with missing feature impossible.""","""Exemplar.generalise: Ăs\̈ʉB"""
"""""","""Exemplar.preGeneralise : Incompatible instance's class.""","""Exemplar.preGeneralise: ȂCX^X̃NXB"""
"""""","""Exemplar.preGeneralise : Generalisation with missing feature impossible.""","""Exemplar.preGeneralise: Ăs\̈ʉB"""
"""""","""Exemplar.validateGeneralisation : validateGeneralisation called without previous call to preGeneralise!""","""Exemplar.validateGeneralisation: validateGeneralisation͑ǑĂяoȂpreGeneraliseɌĂт܂!"""
"""""","""Exemplar.cancelGeneralisation : cancelGeneralisation called without previous call to preGeneralise!""","""Exemplar.cancelGeneralisation: cancelGeneralisation͑ǑĂяoȂpreGeneraliseɌĂт܂!"""
"""""","""Exception.getMinBorder : not numeric attribute !""","""Exception.getMinBorder: lłȂ!"""
"""""","""Exception.getMinBorder : empty Exemplar !""","""Exception.getMinBorder: Exemplar!"""
"""""","""Exception.getMaxBorder : not numeric attribute !""","""Exception.getMaxBorder: lłȂ!"""
"""""","""Exception.getMaxBorder : empty Exemplar !""","""Exception.getMaxBorder: Exemplar!"""
"""""","""Exemplar[""","""{"""
"""""","""Empty]""",""""""
"""""","""No Rules (Empty Exemplar)""","""K܂B(̎{)"""
"""""","""Class type must be nominal!""","""NX^Cv͖ڏłɈႢ܂!"""
"""""","""NNge.classifyInstance : Incompatible instance types !""","""NNge.classifyInstance: ȂCX^X^Cv!"""
"""""","""NNge.classifyInstance : NNge hasn't been trained !""","""NNge.classifyInstance: NNge͌PĂ܂!"""
"""""","""Incompatible instance types""","""ȂCX^X^Cv"""
"""""","""NNge.updateMI : incorrect number of folders ! Option I must be greater than 1.""","""NNge.updateMI: tH_[!smȐOption I1ȏłɈႢ܂B"""
"""""","""NNge.updateMI : Cannot deal with 'string attribute'.""","""NNge.updateMI: 'XgO'ɑΏ邱Ƃł܂B"""
"""""","""\nNNGE classifier\n\nRules generated :\n""","""nNNGENVt@CA\n\nRules\: \n"""
"""""","""\nStat :\n""","""\nStat: \n"""
"""""","""\tclass ""","""\tclass"""
"""""",""" exemplar(s) including """,""" {"""
"""""","""\n\tTotal : ""","""\n\tTotal: """
"""""",""" exemplars(s) including """,""" {"""
"""""",""" Hyperrectangle(s) and """,""" Hyperrectangle(s)B"""
"""""",""" Single(s).\n""",""" VO\n"""
"""""","""\tFeature weights : ""","""\tFeatured: """
"""""","""\tNumber of attempts of generalisation.\n""","""ʉ\n݂̎\tNumber"""
"""""","""-G <value>""","""-G<l>"""
"""""","""\tNumber of folder for computing the mutual information.\n""","""݂̏vZ邽߂̃tH_[\tNumberA\n"""
"""""","""-I <value>""","""-<l>"""
"""""","""NNge.setOptions : G option's value must be greater than 1.""","""NNge.setOptions: GIvV̒l1ȏłȂ΂Ȃ܂B"""
"""""","""NNge.setOptions : I option's value must be greater than 1.""","""NNge.setOptions: ̓IvV̂̂A]1ΈȏłɈႢ܂B"""
"""""","""Sets the number of attempts for generalization.""","""ʉ̂߂݂̎̐ݒ肵܂B"""
"""""","""Sets the number of folder for mutual information.""","""݂̏ɃtH_[̐ݒ肵܂B"""
"""""","""Class for building and using a 1R classifier; in other words, uses ""","""1RNVt@CAgĂāAgp邽߂̃NX; ΁Apr"""
"""""","""the minimum-error attribute for prediction, discretizing numeric ""","""\AUl̂߂̍ŏ̌葮"""
"""""","""attributes. For more information, see\n\n:""","""B ڂ́A\n\nĂ:"""
"""""","""R.C. Holte (1993). ""Very simple classification rules """,""""""
"""""","""perform well on most commonly used datasets"". Machine Learning, """,""""""
"""""","""Vol. 11, pp. 63-91.""",""""""
"""""","""not ?""","""?"""
"""""",""" instances correct)\n""",""" ႪCA)A\n"""
"""""","""Can't print OneR classifier!""","""OneRNVt@CA邱Ƃł܂!"""
"""""","""Can't handle numeric class!""","""lNXƂł܂!"""
"""""","""Only missing values in the training data!""","""g[jOf[^̌l!"""
"""""","""\tThe minimum number of objects in a bucket (default: 6).""","""oPc(ftHg: 6)̒\tThe̍ŏ̔ԍ̃IuWFNgB"""
"""""","""-B <minimum bucket size>""","""-B<ŏ̃oPcTCY>"""
"""""","""OneR: No model built yet.""","""OneR: ǂȃf܂ĂĂ܂łB"""
"""""","""The minimum bucket size used for discretizing numeric ""","""UlɎgpŏ̃oPcTCY"""
"""""","""attributes.""","""B"""
"""""","""Can't print rule.""","""K邱Ƃł܂B"""
"""""",""" AND\n""",""" āA\n"""
"""""","""No training instances/Only instances with missing class!""","""ĂNXg[jO/B̗Ⴊ܂!"""
"""""","""Number of Rules  : \t""","""K̐: \t"""
"""""","""Class for generating a PART decision list. Uses ""","""PART𐶐邽߂̃NX͋Lڂ܂B pr"""
"""""","""separate-and-conquer. Builds a partial C4.5 decision tree ""","""؂藣ĂAāAĂB IC4.5ӎv̎}Ă܂B"""
"""""","""in each iteration and makes the ""best"" leaf into a rule. ""","""Kւ̊eJԂƑɂuułǁvvtB"""
"""""","""For more information, see:\n\n""","""ڂ́A: \n\nĂB"""
"""""","""Eibe Frank and Ian H. Witten (1998). ""Generating """,""""""
"""""","""Accurate Rule Sets Without Global Optimization.""""",""""""
"""""","""In Shavlik, J., ed., Machine Learning: Proceedings of the """,""""""
"""""","""Fifteenth International Conference, Morgan Kaufmann Publishers.""",""""""
"""""","""\tSet minimum number of objects per leaf.\n""","""\tSet̍ŏ̔ԍ̗t\ñIuWFNg"""
"""""","""-M <minimum number of objects>""","""-M<ŏ̐̕>"""
"""""","""\tGenerate unpruned decision list.""","""\tGenerate unpruned胊XgB"""
"""""","""Setting CF doesn't make sense ""","""CFݒ肷̂͗ł܂B"""
"""""","""CF has to be greater than zero and smaller than one!""","""CF̓[肷΂炵āA1菬Ȃ΂Ȃ܂!"""
"""""",""" does only make sense for""",""" ł邾łB"""
"""""",""" reduced error pruning.""",""" 芠荞݂}܂B"""
"""""","""PART decision list\n------------------\n\n""","""PART胊Xg\n------------------\n\n"""
"""""","""Number of rules: ""","""[̐: """
"""""",""" not supported (PART)""",""" T|[g܂B(PART)"""
"""""","""The minimum number of instances per rule.""","""1[̍ŏf[^B"""
"""""",""" One fold is used for pruning, the rest for growing the rules.""",""" 1̐܂ڂ荞݂ɎgpāA邽߂̎c͋KłB"""
"""""","""building the partial trees.""","""IȖ؂Ă܂B"""
"""""","""Class for building and using a PRISM rule set for classification. ""","""PRISMKzグāAgp邽߂̃NX͕ނ̂߂ɃZbg܂B"""
"""""","""Can only deal with nominal attributes. Can't deal with missing values. ""","""ڏ̑ɑΏ邱Ƃł邾łB lɑΏ邱Ƃł܂B"""
"""""","""Doesn't do any pruning. For more information, see \n\n""","""ǂȊ荞݂܂B ڂ́A\n\nĂB"""
"""""","""J. Cendrowska (1987). ""PRISM: An algorithm for """,""""""
"""""","""inducing modular rules"". International Journal of Man-Machine """,""""""
"""""","""Studies. Vol.27, No.4, pp.349-370.""",""""""
"""""","""\n   and ""","""\nB"""
"""""",""" then """,""" ̎"""
"""""","""Can't print Prism classifier!""","""PrismNVt@CA邱Ƃł܂!"""
"""""","""Prism can't handle a numeric class!""","""vY͐lNXƂł܂!"""
"""""","""Prism can only deal with nominal attributes!""","""vY͖ڏ̑ɑΏ邱Ƃł邾ł!"""
"""""","""Prism can't handle attributes with missing values!""","""vY͌lőƂł܂!"""
"""""","""No instances with a class value!""","""KlCX^X܂!"""
"""""","""Prism: No model built yet.""","""vY: ǂȃf܂ĂĂ܂łB"""
"""""","""Prism rules\n----------\n""","""vY\n𓝎܂B----------\n"""
"""""","""The implementation of a RIpple-DOwn Rule learner. ""","""RIpple-DOwn RulewK҂̎B"""
"""""","""It generates a default rule first and then the exceptions for the default rule ""","""́Aȗ̉߂̂߂ɏȗ̉߂1ԖڂƎɁAOłƐ܂B"""
"""""","""with the least (weighted) error rate.  Then it generates the ""best"" exceptions for ""","""ł(׏d)łȂ藦ŁB uułǁvvO𔭐邻̎"""
"""""","""each exception and iterates until pure.  Thus it performs a tree-like expansion of ""","""āAeOAɂȂ܂ŌJԂ܂B ̌ʁAa؂̂悤Ȋgs܂B"""
"""""","""exceptions.""","""OB"""
"""""","""The exceptions are a set of rules that predict classes other than the default. ""","""O̓ftHgȊÕNX\1Zbg̋KłB"""
"""""","""IREP is used to generate the exceptions.""","""IREṔAO𔭐̂Ɏgp܂B"""
"""""","""Get""","""ĂB"""
"""""","""Something wrong here inside findRule()!""","""AfindRule()̒̕s!"""
"""""","""  Except """,""" ĂB"""
"""""","""AND""",""""""
"""""",""" Only nominal class, please.""",""" ڏ̃NX肢܂B"""
"""""",""" Only 2 classes, please.""",""" 2̃NX肢܂B"""
"""""",""" No training data.""",""" g[jOf[^܂B"""
"""""",""" The class labels of all the training data are missing.""",""" ׂẴg[jOf[^̃NXx͌Ă܂B"""
"""""",""" Not enough data for REP.""",""" REPɏ\ȃf[^łȂB"""
"""""",""") and """,""") """
"""""","""No training data.""","""g[jOf[^܂B"""
"""""","""The class labels of all the training data are missing.""","""ׂẴg[jOf[^̃NXx͌Ă܂B"""
"""""","""Only nominal class, please.""","""ڏ̃NX肢܂B"""
"""""","""otherClasses""",""""""
"""""","""defClass""",""""""
"""""","""newClass""",""""""
"""""","""\tSet number of folds for IREP\n""","""IREP\n̐܂ڂ\tSetԍ"""
"""""","""\tOne fold is used as pruning set.\n""","""tOne܂d˂\̓Zbg\n𙒒肷ƂĎgp܂B"""
"""""","""\tSet number of shuffles to randomize\n""","""\n_}CYVbt\tSetԍ"""
"""""","""\tthe data in order to get better rule.\n""","""\́AǂK\n𓾂邽߂Ƀf[^tthe܂B"""
"""""","""-S <number of shuffles>""","""-S<Vbt̐>"""
"""""","""\tSet flag of whether use the error rate \n""","""\tSetoށA藦\ngpĂB"""
"""""","""\tof all the data to select the default class\n""","""\tofׂ͂āAftHgNX\nIf[^łB"""
"""""","""\tin each step. If not set, the learner will only use""","""\XY͂ꂼꓥ܂܂B łȂ΁AZbgAwK҂͎gp]ł܂B"""
"""""","""\tthe error rate in the pruning data""","""荞݃f[^\tthe藦"""
"""""","""\t Set flag of whether use the majority class as\n""","""\t SetoށA\nƂđ命̃NXgpĂB"""
"""""","""\tthe default class in each step instead of \n""","""\n̑ɊeXebvɂ\ttheftHg̃NX"""
"""""","""\tchoosing default class based on the error rate\n""","""藦\nɊÂftHg̃NXtchoosing\"""
"""""","""\t(if the flag is not set)""","""\t(ݒ肳ȂȂ)"""
"""""","""\tSet the minimal weights of instances\n""","""\n̍ŏʂ̏d\tSet"""
"""""","""\twithin a split.\n""","""\twithin\nłB"""
"""""","""\t(default 2.0)""","""\t(ftHg2.0)"""
"""""","""-N <min. weights>""","""-Nd݂<>"""
"""""","""Determines how often the data is shuffled before a rule ""","""f[^K̑Oɂǂꂭ炢̕pxŃVbt邩肵܂B"""
"""""","""is chosen. If > 1, a rule is learned multiple times and the ""","""I΂Ă܂B > 1AK̉w΂B"""
"""""","""most accurate rule is chosen.""","""łmȋK͑I΂Ă܂B"""
"""""","""Whether worth of rule is computed based on all the data ""","""K̉lׂẴf[^ɊÂČvZ"""
"""""","""or just based on data covered by rule.""","""܂́Af[^ɊÂċKłJo[Ă܂B"""
"""""","""Whether the majority class is used as default.""","""命̃NX̓ftHgƂĎgp܂?"""
"""""","""The minimum total weight of the instances in a rule.""","""Kɂ̍ŏ̑SdʁB"""
"""""",""" not supported (Ripple down rule learner)""",""" x܂B(KwK҂̉ɂgN܂)"""
"""""","""RIpple DOwn Rule Learner(Ridor): No model built yet.""","""KwK(Ridor)̉ɂgNĂ: ǂȃf܂ĂĂ܂łB"""
"""""","""RIpple DOwn Rule Learner(Ridor) rules\n""","""RIpple DOwn Rule Learner(Ridor)\n𓝎܂B"""
"""""","""\nTotal number of rules (incl. the default rule): ""","""K(inclȗ̉)\nTotalԍ: """
"""""","""!!!theory: ""","""!!!_: """
"""""","""MDL and categorical theories (Continued)""","""MDLƒfIȗ_()łB"""
"""""","""!!!cover: ""","""!!!Jo[: """
"""""","""|uncover""","""|ĂB"""
"""""","""|coverBits: """,""""""
"""""","""|uncBits: """,""""""
"""""","""|FPRate: """,""""""
"""""","""|expErr: """,""""""
"""""","""|total: ""","""|v: """
"""""","""!!!inside potential: ""","""!!!ʂ̉\: """
"""""","""!!!Enter without: ""","""!!!ȉȂœĂB """
"""""","""!!!without: ""","""!!!: """
"""""","""!!!Enter with: ""","""!!!ȉƋɓĂB """
"""""","""!!!with: ""","""!!!: """
"""""",""" |potential: """,""" |\: """
"""""","""!!!deleted (""","""!!!폜A("""
"""""","""): save ""","""): ߖ񂵂ĂB"""
"""""","""Class for building and using a 0-R classifier. Predicts the mean ""","""0-Rފ̍\zɗp܂D̕ފ́Clɑ΂ĕς\C"""
"""""","""(for a numeric class) or the mode (for a nominal class).""","""`ɂĂ͍ŕpl\܂D"""
"""""","""ZeroR can only handle nominal and numeric class""","""ZeroR͐lƖ`̃NX̂"""
"""""",""" attributes.""",""" ŗpł܂D"""
"""""","""ZeroR: No model built yet.""","""ZeroR: ܂f\zĂ܂D"""
"""""","""ZeroR predicts class value: ""","""ZeroR̓NX\܂: """
"""""","""\tFull name of base classifier.\n""","""\tx[Xފ̊SȖO\n"""
"""""","""\t(default: ""","""\t(ftHg:"""
"""""","""The base classifier to be used.""","""gpx[XފD"""
"""""","""Class for generating an alternating decision tree. The basic ""","""݌؂̐D"""
"""""","""algorithm is based on:\n\n""","""{IȃASY͈ȉ̕ɊÂĂ܂: \n\n"""
"""""","""Freund, Y., Mason, L.: ""The alternating decision tree learning algorithm"". """,""""""
"""""","""Proceeding of the Sixteenth International Conference on Machine Learning, """,""""""
"""""","""Bled, Slovenia, (1999) 124-133.\n\n""",""""""
"""""","""This version currently only supports two-class problems. The number of boosting ""","""o[W͓lNX݂̂T|[gĂ܂D """
"""""","""iterations needs to be manually tuned to suit the dataset and the desired ""","""u[XeBǑJԂ́Cf[^ZbgƗv镡GEm̃g[hItɓK悤Ɏ蓮ŒKv܂D"""
"""""","""complexity/accuracy tradeoff. Induction of the trees has been optimized, and heuristic ""","""؂̓óCœKC"""
"""""","""search methods have been introduced to speed learning.""","""IȒT@wKxグ邽߂ɓĂ܂D"""
"""""","""Expand all paths""","""ׂĂ̌oHWJ"""
"""""","""Expand the heaviest path""","""łdoHWJ"""
"""""","""Expand the best z-pure path""","""łǂz-pureȌoHWJ"""
"""""","""Expand a random path""","""ׂɌoHWJ"""
"""""","""ADTree: Needs a class to be assigned""","""ADTree: NX蓖Ă̂KvłD"""
"""""","""ADTree: Can't handle string attributes""","""ADTree: 񑮐͈܂D"""
"""""","""ADTree: Class must be nominal""","""ADTree: NX͖`^łȂ΂Ȃ܂D"""
"""""","""ADTree: Must be a two-class problem""","""ADTree: 2NXłȂ΂Ȃ܂D"""
"""""","""Trying to boost with no training data""","""Pf[^ɋ݂Ă܂D"""
"""""","""ADTree not built yet""","""ADTree͂܂\zĂ܂"""
"""""","""Alternating decision tree:\n\n""","""݌: \n\n"""
"""""","""\nLegend: ""","""\n}"""
"""""","""\nTree size (total number of nodes): ""","""\n؂̃TCY(m[h̑): """
"""""","""\nLeaves (number of predictor nodes): ""","""\nt̐(\̂߂̃m[h): """
"""""","""digraph ADTree {\n""",""""""
"""""",""""" shape=box style=filled""",""""""
"""""",""" data=\n""",""""""
"""""",""" [style=dotted]\n""",""""""
"""""","""Sets the number of boosting iterations to perform. You will need to manually ""","""u[XeBOJԂs񐔂ݒ肵܂D"""
"""""","""tune this parameter to suit the dataset and the desired complexity/accuracy ""","""̃p[^̓f[^ZbgƗv镡GEm̃g[hItlĎ蓮ŒKv܂D"""
"""""","""tradeoff. More boosting iterations will result in larger (potentially more ""","""葽̃u[XeBOJԂ񐔂͑傫Ȗ؂ƂȂ錋ʂƂȂ܂DiݓIɂ͂萳mɂȂ܂j"""
"""""",""" accurate) trees, but will make learning slower. Each iteration will add 3 nodes ""","""̕CwK͒xȂ܂D"""
"""""","""(1 split + 2 prediction) to the tree unless merging occurs.""","""ꂼ̌JԂ͂R̃m[hiP͕CQ͗\jNȂǉ܂D"""
"""""","""Sets the type of search to perform when building the tree. The default option""","""؂\zƂ̒Tsނݒ肵܂D"""
"""""",""" (Expand all paths) will do an exhaustive search. The other search methods are""",""" ftHg̃IvV(ׂĂ̌oHWJ) OIȌ邱ƂɂȂ܂D"""
"""""",""" heuristic, so they are not guaranteed to find an optimal solution but they are""",""" ̕@ƂẮCq[XeBbNœKۏ؂͂܂񂪁C͂邩ɑs܂D"""
"""""",""" much faster. Expand the heaviest path: searches the path with the most heavily""",""" łdoH̓WJ: łddݕtCX^XɌoHT܂D"""
"""""",""" weighted instances. Expand the best z-pure path: searches the path determined""",""" ŗǂz-pureoH̓WJ: z-pure\ɂčŗǂƌ߂oHT܂D"""
"""""",""" by the best z-pure estimate. Expand a random path: the fastest method, simply""",""" _oHWJ: łȒT@łD"""
"""""",""" searches down a single random path on each iteration.""",""" Pɂꂼ̌JԂɂĒP̌oH𖳍ׂɒT܂D"""
"""""","""Sets the random seed to use for a random search.""","""_TɎg߂̃_̎ݒ肵܂D"""
"""""","""Sets whether the tree is to save instance data - the model will take up more""","""؂CX^Xf[^ۑ邩ݒ肵܂Dɂ胂f͂葽̃܂D"""
"""""",""" memory if it does. If enabled you will be able to visualize the instances at""",""" CLɂƖ؂Ƃ"""
"""""",""" the prediction nodes when visualizing the tree.""",""" \m[hɊ蓖ĂꂽCX^X邱Ƃł܂D"""
"""""","""\tNumber of boosting iterations.\n""","""\tu[XeBǑJԂ\n"""
"""""","""\t(Default = 10)""","""\t (ftHg=10)"""
"""""","""-B <number of boosting iterations>""","""-B <u[XeBOJԂ>"""
"""""","""\tExpand nodes: -3(all), -2(weight), -1(z_pure), ""","""\tm[h̓WJ: -3(S) -2(d) -1(z_pure)"""
"""""",""">=0 seed for random walk\n""","""OȏŃ_EH[N̂߂̎ƂȂ܂D\n"""
"""""","""\t(Default = -3)""","""\t (ftHg=-3)"""
"""""","""-E <-3|-2|-1|>=0>""","""-E <-3|-2|-1|>=0>"""
"""""","""\tSave the instance data with the model""","""\tCX^X̃f[^fɕۑD"""
"""""","""counted""",""""""
"""""","""measureNumPredictionLeaves""",""""""
"""""","""measureNodesExpanded""",""""""
"""""","""measureExamplesProcessed""",""""""
"""""",""" not supported (ADTree)""",""" T|[gĂ܂(ADTree)"""
"""""","""Trying to merge an uninitialized tree""","""񏉊Ԃ̖؂悤ƂĂ܂D"""
"""""","""Class for building and using a decision stump. Usually used in ""","""fBVWX^v\z邽߂̃NXD"""
"""""","""conjunction with a boosting algorithm. Does regression (based on ""","""ʏCu[XeBOASYƑgݍ킹ėp܂D"""
"""""","""mean-squared error) or classification (based on entropy). Missing ""","""A͕ϓ덷ɊÂCނ̓Ggs[ɊÂĂ܂D"""
"""""","""is treated as a separate value.""","""l͕ʂ̒lƂĈ܂D"""
"""""","""No instances without missing ""","""̖CX^X͂܂D"""
"""""","""class values in training file!""","""Pt@C̃NXl!"""
"""""","""Attribute missing. Need at least one ""","""܂D"""
"""""","""attribute other than class attribute!""","""ȂƂP̑NXĕKvł!"""
"""""","""  public static double classify(Object [] i) {\n""",""""""
"""""","""    if (i[""",""""""
"""""","""] == null) { return """,""""""
"""""",""" } else if (((String)i[""",""""""
"""""",""" } else if (((Double)i[""",""""""
"""""","""]).doubleValue() <= """,""""""
"""""",""") { return """,""""""
"""""",""" } else { return """,""""""
"""""",""" }\n  }\n}\n""",""""""
"""""","""Decision Stump: No model built yet.""","""fBVWEX^v: ܂f\zĂ܂D"""
"""""","""Decision Stump\n\n""","""fBVWEX^v\n\n"""
"""""","""Classifications\n\n""","""\n\n"""
"""""",""" is missing : """,""" Ă܂: """
"""""","""\nClass distributions\n\n""","""\nNXz\n\n"""
"""""",""" is missing\n""",""" Ă܂\n"""
"""""","""Can't print decision stump classifier!""","""fBVWEX^v̕ފo͂邱Ƃł܂!"""
"""""","""Class for constructing an unpruned decision tree based on the ID3 ""","""ID3ASYɊÂ}薳̌؂\z邽߂̃NXD"""
"""""","""algorithm. Can only deal with nominal attributes. No missing values ""","""`݈̂܂Dl͋e܂D"""
"""""","""allowed. Empty leaves may result in unclassified instances. For more ""","""̗tɂ͕ނĂȂCX^X蓖Ă܂D"""
"""""","""information see: \n\n""","""Ȃ͈ȉ̕Q: \n\n"""
"""""",""" R. Quinlan (1986). ""Induction of decision """,""""""
"""""","""trees"". Machine Learning. Vol.1, No.1, pp. 81-106""",""""""
"""""","""Id3: nominal class, please.""","""Id3: `NXw肵ĂD"""
"""""","""Id3: only nominal ""","""Id3: `̂"""
"""""","""attributes, please.""","""w肵ĂD"""
"""""","""Id3: no missing values, ""","""Id3: lȂ悤"""
"""""","""please.""","""肢܂D"""
"""""","""Id3: No model built yet.""","""Id3: ܂f\zĂ܂D"""
"""""","""Id3\n\n""",""""""
"""""",""": null""",""""""
"""""","""((Double) i[""",""""""
"""""",""".doubleValue() <= """,""""""
"""""",""".doubleValue() > """,""""""
"""""","""sourceClass""",""""""
"""""","""Can't print classification tree.""","""ޖ؂o͂邱Ƃł܂D"""
"""""","""Bag num """,""""""
"""""","""Class num ""","""NX"""
"""""","""Abstract""","""v"""
"""""","""Model selection method not implemented""","""fI@͎Ă܂D"""
"""""","""\nLeaf number: ""","""\nt̐: """
"""""","""\nSize of the tree : \t""","""\n؂̃TCY: \t"""
"""""","""Can't print nb tree.""","""nb treeo͂ł܂łD"""
"""""","""digraph J48Tree {\n""",""""""
"""""","""NB model""",""""""
"""""","""NB Model""",""""""
"""""","""Errors for """,""""""
"""""","""This shouldn't happen! glob : ""","""ꂪNׂł͂܂I@glob: """
"""""",""" minRes : """,""""""
"""""","""This shouldn't happen!!!""","""͋Nׂł͂܂!"""
"""""","""no-split""","""Ȃ"""
"""""","""Class is numeric!""","""NXl^ł!"""
"""""","""WARNING: confidence value for pruning ""","""x: }̂߂̐Mpl"""
"""""",""" too high. Error estimate not modified.""",""" ߂܂D덷\l̓G[̂ߕsςłD"""
"""""","""Class for generating a pruned or unpruned C4.5 decision tree. For more ""","""}LÊbSDT؂𐶐NXD"""
"""""","""information, see\n\n""","""ڂ͈ȉ̕Q\n\n"""
"""""","""Ross Quinlan (1993). ""C4.5: Programs for Machine Learning"", """,""""""
"""""","""Morgan Kaufmann Publishers, San Mateo, CA.\n\n""",""""""
"""""","""\tUse unpruned tree.""","""\t}肵ĂȂ؂𗘗p"""
"""""","""\tSet confidence threshold for pruning.\n""","""\t}̂߂̐Mx臒lݒ\n"""
"""""","""\t(default 0.25)""","""\t (ftHg0.25)"""
"""""","""-C <pruning confidence>""","""-C <}̐Mx>"""
"""""","""\tSet minimum number of instances per leaf.\n""","""\ttɊ蓖Ăŏf[^̐ݒD\n"""
"""""","""\t(default 2)""","""\t (ftHg2)"""
"""""","""\tUse reduced error pruning.""","""\tጸ}̗pD"""
"""""","""\tSet number of folds for reduced error\n""","""\tጸ̂߂̐܂Ԃ̐ݒD\n"""
"""""","""\tpruning. One fold is used as pruning set.\n""","""\te܂ڂ͎}WƂėp܂D\n"""
"""""","""\t(default 3)""","""\t(ftHg3)"""
"""""","""\tUse binary splits only.""","""\t񕪊؂̗pD"""
"""""","""\tDon't perform subtree raising.""","""\t؂̏o𐧌D"""
"""""","""\tDo not clean up after the tree has been built.""","""\tؐɏȂD"""
"""""","""\tLaplace smoothing for predicted probabilities.""","""\t\mɑ΂郉vXsD"""
"""""","""-Q <seed>""","""-Q <>"""
"""""","""Subtree raising doesn't need to be unset for unpruned tree!""","""؂̏o͎}薳̖؂ŃZbgȂKv܂!"""
"""""","""Unpruned tree and reduced error pruning can't be selected ""","""}薳̖؂ƌጸ}͓"""
"""""","""simultaneously!""","""I邱Ƃ͂ł܂!"""
"""""","""Setting the confidence doesn't make sense ""","""Mx̐ݒ"""
"""""","""for reduced error pruning.""","""ጸ}̂̂ƂĂ͎󂯓܂D"""
"""""","""Doesn't make sense to change confidence for unpruned ""","""}薳̖؂ɑ΂ĐMx̐ݒςĂ"""
"""""","""tree!""","""Ӗ܂!"""
"""""","""Confidence has to be greater than zero and smaller ""","""Mx͂O傫C"""
"""""","""than one!""","""PȂ΂Ȃ܂!"""
"""""","""Setting the number of folds""","""܂ڂ̐̐ݒ"""
"""""",""" doesn't make sense if""",""" 󂯓܂DC"""
"""""",""" reduced error pruning is not selected.""",""" ጸ}肪IĂƂ΁D"""
"""""","""The seed used for randomizing the data ""","""f[^_̂Ɏ킪p܂D"""
"""""","""when reduced-error pruning is used.""","""ጸ}𗘗pƂɁD"""
"""""","""Whether counts at leaves are smoothed based on Laplace.""","""vXɊÂėtł̐グ邩ǂłD"""
"""""","""J48 unpruned tree\n------------------\n""","""J48@؁@\n------------------\n"""
"""""","""J48 pruned tree\n------------------\n""","""J48 }ρ@\n------------------\n"""
"""""","""The confidence factor used for pruning (smaller values incur ""","""Mx͎}ɑ΂ėp܂D(菬l"""
"""""","""more pruning).""","""葽}s܂)"""
"""""","""The minimum number of instances per leaf.""","""t̍ŏᐔ"""
"""""","""Whether reduced-error pruning is used instead of C.4.5 pruning.""","""ጸ}bSDT̎}̕ςɎgp邩ǂD"""
"""""","""Determines the amount of data used for reduced-error pruning. ""","""ጸ}̂߂ɗpf[^̗ʂ肵ĂD"""
"""""",""" One fold is used for pruning, the rest for growing the tree.""",""" 1̐܂ڕW͎}̂߂ɗpCc͌؂̐ɗp܂D"""
"""""","""Whether to use binary splits on nominal attributes when ""","""`̕ɓ񕪕g"""
"""""","""building the trees.""","""i؂\zƂɁjD"""
"""""","""Whether to consider the subtree raising operation when pruning.""","""؂̏o}̍ۂɍl邩ǂD"""
"""""","""Whether to save the training data for visualization.""","""Pf[^̂߂ɕۑ邩ǂD"""
"""""","""higherRegressions""",""""""
"""""","""unprune""","""}Ȃ"""
"""""","""\n\nNumber of Leaves  : \t""","""\n\nt̐: \t"""
"""""","""\nSize of the Tree : \t""","""\n؂̃TCYipXj: \t"""
"""""","""Can't print logistic model tree""","""WXeBbNf؂o͂ł܂D"""
"""""","""LM_""",""""""
"""""","""digraph LMTree {\n""",""""""
"""""",""" [label=""LM_""",""""""
"""""","""shape=box style=filled""",""""""
"""""","""'pseudo class'""",""""""
"""""","""collect""",""""""
"""""","""maxIterations""",""""""
"""""","""heuristicStop""",""""""
"""""","""\nClass """,""""""
"""""","""Can't select Model without non-class attribute""","""NXł͂ȂɃfI邱Ƃł܂D"""
"""""","""Can't build split on 0 instances""","""OCX^Xł͕𐶐ł܂D"""
"""""","""ResidualSplit: no support for splits on missing values""","""ResidualSplit: l̕ɑ΂T|[g͂܂D"""
"""""","""logistic model tree""","""WXeBbNf"""
"""""","""Logistic Model Trees""","""WXeBbNf"""
"""""","""Nominal class, please.""","""`^̃NX肢܂D"""
"""""","""No instances in training file!""","""Pf[^̃t@CɃCX^X܂!"""
"""""","""Logistic model tree \n------------------\n""","""WXeBbNf\n------------------\n"""
"""""","""No tree build""","""؂\zł܂łD"""
"""""","""\tBinary splits (convert nominal attributes to binary ones)\n""","""\tl(`͓lQɕϊ܂)\n"""
"""""","""\tSplit on residuals instead of class values\n""","""\tNXl̕ςɎcƂɕsD\n"""
"""""","""\tUse cross-validation for boosting at all nodes (i.e., disable heuristic)\n""","""\tSẴm[hɂu[XeBÔ߂̗̌piq[XeBbN̗p~jD\n"""
"""""","""\tUse error on probabilities instead of misclassification error ""","""\t땪ތ̑ɌmgpD"""
"""""","""for stopping criterion of LogitBoost.\n""","""LogitBoost̒~]̂߂\n"""
"""""","""\tSet fixed number of iterations for LogitBoost (instead of using ""","""\tLogitBoost̂߂̌Œ肵JԂ̐ݒ"""
"""""","""cross-validation)\n""",""(̎gp̕ς) \n"""
"""""","""-I <numIterations>""","""-I <JԂ>"""
"""""","""\tSet minimum number of instances at which a node can be split (default 15)\n""","""\tm[hŒCX^X̐ݒ (ftHg 15)\n"""
"""""","""-M <numInstances>""","""-M <CX^X>"""
"""""",""" not supported (LMT)""",""" T|[gĂ܂(LMT)"""
"""""","""Classifier for building 'logistic model trees', which are classification trees with ""","""'WXeBbNf'\z镪ފD"""
"""""","""logistic regression functions at the leaves. The algorithm can deal with binary and multi-class ""","""́CtɂăWXeBNXA֐蓖Ăޖ؂łD ASY͓lƑl̂炷C"""
"""""","""target variables, numeric and nominal attributes and missing values. ""","""āClC`ƌlɑΉĂ܂D"""
"""""","""For more information see: N.Landwehr, M.Hall, E. Frank 'Logistic Model Trees' (ECML 2003).""","""ڂɊւẮCȉ̕Q: N.Landwehr, M.Hall, E.Frank 'Logistic Model Trees'(ECML2003)"""
"""""","""Convert all nominal attributes to binary ones before building the tree. ""","""؂\zOɑSĂ̖`l̑QɕϊĂD"""
"""""","""This means that all splits in the final tree will be binary.""","""́CŏIIɖ؂̑̕SĂlɂȂ邱ƂӖĂ܂D"""
"""""","""Set splitting criterion based on the residuals of LogitBoost. ""","""LogitBoost̎cɊÂ]ݒ肵ĂD"""
"""""","""There are two possible splitting criteria for LMT: the default is to use the C4.5 ""","""LMTɂ͂Q̕]܂: ftHgC4.5Ŏg񗘓ŁC"""
"""""","""splitting criterion that uses information gain on the class variable. The other splitting ""","""NXl̕ɊÂĂ܂D"""
"""""","""criterion tries to improve the purity in the residuals produces when fitting the logistic ""","""̕́CWXeBNXA֐̎cɂ鏃ǂ悤ɂ܂D"""
"""""","""regression functions. The choice of the splitting criterion does not usually affect classification ""","""ʏC]͕ސxɉe܂D"""
"""""","""accuracy much, but can produce different trees.""","""CقȂ؂𐶐܂D"""
"""""","""Use heuristic that avoids cross-validating the number of Logit-Boost iterations at every node. ""","""m[hLogit-BoosťJԂ̌邱Ƃq[XeBbNgpĂD"""
"""""","""When fitting the logistic regression functions at a node, LMT has to determine the number of LogitBoost ""","""m[hɂăWXeBNXA֐KƂCLMTLogitBoosťJԂ肵Ȃ΂Ȃ܂D"""
"""""","""iterations to run. Originally, this number was cross-validated at every node in the tree. ""","""XC͖̐؂̑SẴm[hɂČ邽߂̐łD"""
"""""","""To save time, this heuristic cross-validates the number only once and then uses that number at every ""","""Ԃߖ񂷂邽߁C̃q[XeBbN̐x肪sCꂩSẴm[hɂĎs܂D"""
"""""","""node in the tree. Usually this does not decrease accuracy but improves runtime considerably.""",""" ʏC͐𗦂܂񂪁CsԂȂP܂D"""
"""""","""Minimize error on probabilities instead of misclassification error when cross-validating the number ""","""LogitBoosťJԂɂsƂC땪ތ̑Ɍmŏ܂D"""
"""""","""of LogitBoost iterations. When set, the number of LogitBoost iterations is chosen that minimizes ""","""ݒ肳ꂽCLogitBoosťJԂ́C"""
"""""","""the root mean squared error instead of the misclassification error.""","""땪ތ̑ɍϓŏ悤I΂܂D"""
"""""","""Set a fixed number of iterations for LogitBoost. If >= 0, this sets a fixed number of LogitBoost ""","""LogitBoost̂߂̌JԂ萔ݒ肵ĂD >=0łȂC؂̂ǂłLLogitBoosťJԂ萔ݒ肵܂D"""
"""""","""iterations that is used everywhere in the tree. If < 0, the number is cross-validated.""","""<0łȂC̐Ō肪s܂D"""
"""""","""Set the minimum number of instances at which a node is considered for splitting. ""","""m[h̕ɕKvȃCX^X̍ŏݒ肵ĂD"""
"""""","""The default value is 15.""","""ftHgl15łD"""
"""""","""Print impurity values:\n""","""sl̏o: \n"""
"""""","""    Number of total instances:\t""","""    CX^X̐:\t"""
"""""","""    Splitting attribute:\t\t""","""    :\t\t"""
"""""","""    Number of the instances in the left:\t""","""    ̃CX^X̐:\t"""
"""""","""    Number of the instances in the right:\t""","""    ẼCX^X̐:\t"""
"""""","""    Sum of the left:\t\t\t""","""    ̍v:\t\t\t"""
"""""","""    Sum of the right:\t\t\t""","""    E̍v:\t\t\t"""
"""""","""    Squared sum of the left:\t\t""","""    ̓悳ꂽv:\t\t"""
"""""","""    Squared sum of the right:\t\t""","""    E̓悳ꂽv:\t\t"""
"""""","""    Standard deviation of the left:\t""","""    ̕W΍:\t"""
"""""","""    Standard deviation of the right:\t""","""    E̕W΍:\t"""
"""""","""    Variance of the left:\t\t""","""    ̕U:\t\t"""
"""""","""    Variance of the right:\t\t""","""    E̕U:\t\t"""
"""""","""    Overall standard deviation:\t\t""","""    Ŝ̕W΍:\t\t"""
"""""","""    Overall variance:\t\t\t""","""    Ŝ̕U:\t\t\t"""
"""""","""    Impurity (order ""","""   s (I[_["""
"""""","""wrong type in Impurity.incremental().""","""Impurity.incremental()̊Ԉ^CvłD"""
"""""","""Impurity order less than zero in Impurity.incremental()""","""Impurity.incremental()ł̕s̓[ȉłD"""
"""""","""The original algorithm M5 was invented by Quinlan:\n""","""IWĩASYQuinlan̊JM5ł: \n"""
"""""","""Quinlan J. R. (1992). Learning with continuous classes. Proceedings of """,""""""
"""""","""the Australian Joint Conference on Artificial Intelligence. 343--348. """,""""""
"""""","""World Scientific, Singapore.\n""","""\n"""
"""""","""Yong Wang made improvements and created M5':\n""","""'Yong WangM5ǂCM5'쐬܂: \n"""
"""""","""Wang, Y and Witten, I. H. (1997). Induction of model trees for """,""""""
"""""","""predicting continuous classes. Proceedings of the poster papers of """,""""""
"""""","""the European Conference on Machine Learning. University of Economics, """,""""""
"""""","""Faculty of Informatics and Statistics, Prague.""",""""""
"""""","""\tUse unpruned tree/rules\n""","""\t}薳̖؁E[gp\n"""
"""""","""\tUse unsmoothed predictions\n""","""\t̗\gp\n"""
"""""","""\tBuild regression tree/rule rather ""","""\tA؁EA[̍\zD"""
"""""","""than a model tree/rule\n""","""ނ냂f؁E[\zD\n"""
"""""","""\tSet minimum number of instances ""","""\ttɑ΂ŏCX^X̐ݒ"""
"""""","""per leaf\n\t(default 4)""","""\n\t(ftHg4)"""
"""""","""Built rule : ""","""[̍\z: """
"""""","""Classifier has not been built yet!""","""ފ͂܂\zĂ܂!"""
"""""","""Error in predicting (DecList)""","""\ɂ(DecList)"""
"""""","""Classifier hasn't been built yet!""","""ފ͂܂\zĂ܂!"""
"""""","""rules ""","""[Q"""
"""""","""\n(using smoothed linear models) ""","""\n(`f悤) """
"""""","""Number of Rules : ""","""[: """
"""""","""Rule: ""","""[: """
"""""",""" not supported (M5)""",""" T|[gĂ܂(M5)"""
"""""","""Rule does not classify instance""","""[̓CX^X𕪗ނ܂D"""
"""""","""Unable to generate rule!""","""[𐶐ł܂!"""
"""""","""Tree/Rule has not been built yet!""","""/[͂܂\zĂ܂!"""
"""""","""unpruned ""","""}薳"""
"""""","""pruned ""","""}L"""
"""""","""regression ""","""A"""
"""""","""model ""","""f"""
"""""","""(using smoothed linear models)\n""","""(ꂽ`f̎gp)\n"""
"""""","""\nNumber of Rules : ""","""\n[: """
"""""","""IF\n""",""""""
"""""","""THEN\n""",""""""
"""""","""Can't print rule""","""[o͂ł܂D"""
"""""","""Classifier has not been built correctly.""","""ފ͐\z܂łD"""
"""""","""\nLM num: ""","""\n`f: """
"""""","""In to string""",""""""
"""""","""Node:\n\tnum inst: ""","""m[h:\n\tCX^X: """
"""""","""\n\tleaf""","""\n\tt"""
"""""","""\tnode""","""\tm[h"""
"""""","""\n\tSplit att: ""","""\n\t:"""
"""""","""\n\tSplit val: ""","""\n\tl:"""
"""""","""\n\tLM num: ""","""\n\t`f:"""
"""""","""\n\tLinear model\n""","""\n\t`f\n"""
"""""",""" false : """,""" :"""
"""""",""" true : """,""" :"""
"""""","""NULL\n""",""""""
"""""",""" [label=""LM """,""""""""""""
"""""",""""" shape=box style=filled """,""""""
"""""","""data=\n""",""""""
"""""",""" [label=""<=""",""""""
"""""",""" [label="">""",""""""
"""""","""Print statistic values of instances (""","""CX^X̓vlo("""
"""""","""    Number of instances:\t""","""    f[^̐: \t"""
"""""","""    NUmber of instances with unknowns:\t""","""    l̂f[^̐: \t"""
"""""","""    Attribute:\t\t\t:""","""    :\t\t\t:"""
"""""","""    Sum:\t\t\t""","""    v:\t\t\t"""
"""""","""    Squared sum:\t\t""","""    捇v:\t\t"""
"""""","""    Stanard Deviation:\t\t""","""    W΍:\t\t"""
"""""","""Print SplitInfo:\n""","""ʂ̏o:\n"""
"""""","""    Instances:\t\t""","""    f[^Zbg:\t\t"""
"""""","""    Maximum Impurity Reduction:\t""","""    ő̕s: \t"""
"""""","""    Left average:\t""","""    ̕: \t"""
"""""","""    Right average:\t""","""    E̕: \t"""
"""""","""    Splitting function:\t""","""    ֐: \t"""
"""""","""    Splitting function:\tnull\n""","""   ֐:\tnull\n"""
"""""","""digraph M5Tree {\n""",""""""
"""""","""\tSave instances at the nodes in\n""","""\t؂̃m[hɂCX^X̕ۑ\n"""
"""""","""\tthe tree (for visualization purposes)\n""","""\t(ړÎ)\n"""
"""""","""Class for generating a decision tree with naive Bayes classifiers at ""","""tɂăiCuExCYފ؂𐶐NXD"""
"""""","""the leaves. For more information, see\n\nRon Kohavi (1996). Scaling up """,""" ڂ͈ȉ̕Q\n\nRon Kohavi(1996). Scaling up"""
"""""","""the accuracy of naive-Bayes classifiers: a decision tree hybrid. Procedings """,""""""
"""""","""of the Second Internaltional Conference on Knoledge Discovery and Data Mining.""",""""""
"""""","""No classifier built""","""ފ͍\z܂łD"""
"""""","""NBTree\n------------------\n""",""""""
"""""","""Number of leaves: ""","""t̐: """
"""""","""Size of the tree: ""","""؂̃TCY: """
"""""",""" not supported (j48)""",""" T|[gĂ܂(j48)"""
"""""","""measureNumLeaves""",""""""
"""""","""measureNumRules""",""""""
"""""","""Class for constructing a forest of random trees. For more information ""","""_ɐ؂ɂĐX\zNXD"""
"""""","""see: \n\n""","""ڂɂĂ͈ȉ̕Q: \n\n"""
"""""","""Leo Breiman. ""Random Forests"". Machine Learning 45 (1):5-32, October 2001.""",""""""
"""""","""The number of trees to be generated.""","""؂̐D"""
"""""","""The number of attributes to be used in random selection (see RandomTree).""","""_IŎg鑮iRandomTreeQƁjD"""
"""""","""The random number seed to be used.""","""̎ƂĎg鐔lD"""
"""""","""measureOutOfBagError""",""""""
"""""",""" not supported (RandomForest)""",""" T|[gĂ܂(RandomForest)"""
"""""","""\tNumber of trees to build.""","""\t؂̐"""
"""""","""-I <number of trees>""","""-I <؂̐>"""
"""""","""\tNumber of features to consider (<1=int(logM+1)).""","""\tl鑮 (<1=int(logM+1))D"""
"""""","""-K <number of features>""","""-K <̐>"""
"""""","""Random forest not built yet""","""_EtHXg͂܂\zĂ܂D"""
"""""","""Random forest of ""","""_EtHXg̖؂́C"""
"""""",""" trees, each constructed while considering ""","""ꂼꂪ"""
"""""",""" random feature""",""" ׂɑグȂ琶܂D"""
"""""","""Out of bag error: ""","""oOł͂ȂG[: """
"""""","""Class for constructing a tree that considers K randomly ""","""K̑em[hőIĖ؂\zNXD"""
"""""",""" chosen attributes at each node. Performs no pruning.""","""}͍s܂D"""
"""""","""Sets the number of randomly chosen attributes.""","""_ɑI΂鑮̐ݒD"""
"""""","""Whether debug information is output to the console.""","""R\[ɃfobÔ߂̏o͂邩ǂD"""
"""""","""The random number seed used for selecting attributes.""","""I邽߂Ɏg闐̎̐lD"""
"""""","""\tNumber of attributes to randomly investigate\n""","""\t_ɒׂ鑮̐\n"""
"""""","""\t(<1 = int(log(#attributes)+1)).""","""\t(<1 = int(log()+1))łD"""
"""""","""-K <number of attributes>""","""-K <̐>"""
"""""","""\tSet minimum number of instances per leaf.""","""\tt̍ŏCX^XݒD"""
"""""","""\tTurns debugging info on.""","""\tfobÔ߂̏o͂悤ɂ܂D"""
"""""","""\tSeed for random number generator.\n""","""\t̂߂̎D"""
"""""","""RandomTree: Nominal class, please.""","""RandomTree: `NXƂĐݒ肵ĂD"""
"""""","""RandomTree: zero training instances or all ""","""RandomTree: Pf[^ɃCX^X݂ȂC"""
"""""","""RandomTree: Attribute missing. Need at least ""","""RandomTree: SĂ̑Ă܂DȂƂ"""
"""""","""one attribute other than class attribute!""","""P̑NXƂ͕ʂɕKvł!"""
"""""","""RandomTree: no model has been built yet.""","""RandomTree: f͈ˑRƂč\zĂ܂D"""
"""""","""\nRandomTree\n==========\n""",""""""
"""""","""RandomTree: tree can't be printed""","""RandomTree: ؂o͂邱Ƃł܂D"""
"""""","""Fast decision tree learner. Builds a decision/regression tree using ""","""Ȍ؊wKASYD ؂A؂"""
"""""","""information gain/variance and prunes it using reduced-error pruning ""","""񗘓EUgč\zāCጸ}s܂D"""
"""""","""(with backfitting).  Only sorts values for numeric attributes ""","""l͂Px񑀍󂯂邾łD"""
"""""","""once. Missing values are dealt with by splitting the corresponding ""","""l̓CX^X̕zɏ]Ĉ܂D"""
"""""","""instances into pieces (i.e. as in C4.5).""","""́CC4.5ɂ̂ƓłD"""
"""""","""] == null""",""""""
"""""","""((Double)i[""",""""""
"""""","""]).doubleValue() < """,""""""
"""""","""  static double N""",""""""
"""""","""(Object []i) {\n""",""""""
"""""","""else if (""",""""""
"""""","""    return p;\n  }\n""",""""""
"""""","""shape=box]\n""",""""""
"""""","""Decision tree: tree can't be printed""",""": ؂o͂ł܂D"""
"""""","""Whether pruning is performed.""","""}s邩ǂD"""
"""""","""The minimum total weight of the instances in a leaf.""","""tɊ蓖ĂꂽCX^X̑dʂ̍ŏlD"""
"""""","""The minimum proportion of the variance on all the data ""","""Sf[^ł̕U̍ŏD"""
"""""","""that needs to be present at a node in order for splitting to ""","""́Cm[h𕪊"""
"""""","""be performed in regression trees.""","""A؂Ƃċ@\邽߂ɕKvłD"""
"""""","""The seed used for randomizing the data.""","""f[^_邽߂ɎgpD"""
"""""","""Determines the amount of data used for pruning. One fold is used for ""","""}Ɏgf[^̗ʂ߂ĂD"""
"""""","""pruning, the rest for growing the rules.""","""P̐܂ڕ͎}ɎgCc̓[𐶐邽߂Ɏg܂D"""
"""""","""The maximum tree depth (-1 for no restriction).""","""؂̐[̍őlD(-1͐ƂӖ܂)"""
"""""","""\tSet minimum number of instances per leaf ""","""\tt̍ŒCX^X̐ݒD"""
"""""","""(default 2).""","""(ftHg 2)D"""
"""""","""-M <minimum number of instances>""","""-M <ŏ̃CX^X>"""
"""""","""\tSet minimum numeric class variance proportion\n""","""\tŗp鐔lNX̕UƌPf[^̕U̍ŏl\n"""
"""""","""\tof train variance for split (default 1e-3).""",""\t"(ftHg 1e-3)"""
"""""","""-V <minimum variance for split>""","""-V <̂߂̍ŏUl>"""
"""""","""\tNumber of folds for reduced error pruning ""","""\tጸ}̂߂̐܂ڐ"""
"""""","""(default 3).""","""(ftHg 3)."""
"""""","""\tSeed for random data shuffling (default 1).""","""\tf[^_ɃVbt邽߂̎D(ftHg 1)"""
"""""","""\tNo pruning.""","""\t}ȂD"""
"""""","""\tMaximum tree depth (default -1, no maximum)""","""\t؂̐[̍ől(ftHg -1C)"""
"""""","""measureTreeSize""",""""""
"""""",""" not supported (REPTree)""",""" T|[gĂ܂(REPTree)"""
"""""","""REPTree: nominal or numeric class!""","""REPTree: l`NXƂĂ!"""
"""""","""REPTree: zero training instances or all ""","""REPTree: Pf[^ɃCX^X݂ȂD"""
"""""","""instances have missing class!""","""܂́CSẴCX^Xl̃NXĂ܂!"""
"""""","""Cannot handle string attributes!""","""^̑Ƃł܂!"""
"""""","""class """,""""""
"""""","""  public static double classify(Object [] i)\n""",""""""
"""""","""    throws Exception {\n\n""",""""""
"""""","""    double p = Double.NaN;\n""",""""""
"""""","""    return p;\n""",""""""
"""""","""digraph Tree {\n""",""""""
"""""","""edge [style=bold]\n""",""""""
"""""","""No attributes other than class. Using ZeroR.\n\n""","""NXȊȎ܂łDZeroRgp܂D\n\n"""
"""""","""REPTree: No model built yet.""","""REPTree: f͂܂ɍ\zĂ܂D"""
"""""","""\nREPTree\n============\n""",""""""
"""""","""\nSize of the tree : ""","""\n؂̃TCY: """
"""""","""im done""",""""""
"""""","""Tree Not Built""","""؂͍\z܂łD"""
"""""","""error: """,""": """
"""""","""Error : Received event from a TreeDisplayer""",""": TreeDisplayer"""
"""""",""" that is unknown to the classifier.""",""" ފɑ΂ĖmłƂCxg󂯎܂D"""
"""""","""Click Yes To Accept The""","""؂󂯓ꍇYesNbNĂD"""
"""""",""" Tree""",""" """
"""""","""Somehow the focus is null""",""""""
"""""","""digraph UserClassifierTree {\n""",""""""
"""""","""node [fontsize=10]\n""",""""""
"""""","""edge [fontsize=10 style=bold]\n""",""""""
"""""","""Interactively classify through visual means.""","""C^NeBuɁAoiŁAނ܂B"""
"""""",""" You are Presented with a scatter graph of the data against two user""",""" Ȃ2[Uɑ΂f[^ɊւUz}PresentedłB"""
"""""",""" selectable attributes, as well as a view of the decision tree.""",""" I\ȑAшӎv̎}̎_B"""
"""""",""" You can create binary splits by creating polygons around data""",""" Ȃ́Af[^̎̑p`쐬邱ƂɂāA2ǐҊ쐬邱Ƃł܂B"""
"""""",""" plotted on the scatter graph, as well as by allowing another""",""" Uz}ƁAʂ̂̂e邱ƂɂāA܂܂B"""
"""""",""" classifier to take over at points in the decision tree should you""",""" ӎv̎}Ń|CgŎčsNVt@CAׂłAȂ"""
"""""",""" see fit.""",""" 悤ɊmɂĂB"""
"""""","""Part of user input so had to catch here""","""āA[U͂̈ꕔ͂ł̃Lb`ɂ܂B"""
"""""","""Are You Sure...\n""","""mɁAȂłc\n"""
"""""","""Click Yes To Accept""","""󂯓邽߂ɂ͂NbNĂB"""
"""""",""" The Tree""",""" """
"""""","""\n Click No To Return""","""Ԃ\nNbNm["""
"""""","""Accept Tree""","""؂󂯓ĂB"""
"""""","""Tree Visualizer""","""؂̉u"""
"""""","""Data Visualizer""","""f[^u"""
"""""","""ret""","""ZĂB"""
"""""","""ihere""",""""""
"""""","""ehlpe""",""""""
"""""","""leaf""","""t"""
"""""","""miss""","""~X"""
"""""","""RECT""",""""""
"""""","""Classified by ""","""ނɂ"""
"""""","""Split on ""","""܂B"""
"""""","""Classified by\\n""","""\\nɂĕނ܂B"""
"""""","""Standard Deviation = ""","""W΍="""
"""""","""Split on\\n""","""\\nł́A܂B"""
"""""",""" AND\\n""",""" āA\\n"""
"""""",""" A num """,""" num"""
"""""","""shape=box ""","""`="""
"""""","""shape=ellipse ""","""`=ȉ~"""
"""""","""style=filled color=gray95]\n""","""X^C=F=gray95ςɂA\n"""
"""""",""" [label=""True""]\n""",""" uv u{łv=xĂAvA\n"""
"""""",""" [label=""False""]\n""",""" uv uUv=xĂAvA\n"""
"""""",""" (In Set)""",""" (Zbgɂ)"""
"""""",""" (Not in Set)""",""" (ZbgłȂ̂ɂ)"""
"""""","""Null distribution predicted""","""\ꂽkz"""
"""""","""Unable to cluster instance""","""CX^XQ邱Ƃł܂B"""
"""""","""ClusterEvaluation: Class must be nominal!""","""ClusterEvaluation: NX͖ڏłɈႢ܂!"""
"""""","""Clustered Instances\n\n""","""QĂ\n\n"""
"""""","""\nUnclustered instances : ""","""\͗nUnclustered܂: """
"""""","""\n\nClass attribute: ""","""\n\nClass͌ʂƍl܂: """
"""""","""Classes to Clusters:\n""","""NX^ւ̃NX: \n"""
"""""","""No class\n""","""NX\܂nB"""
"""""","""\nIncorrectly clustered instances :\t""","""\͗: \tnIncorrectlyɌQ܂B"""
"""""","""confusion""",""""""
"""""","""  <-- assigned to cluster\n""",""" <--NX^\nɊ蓖Ă܂B"""
"""""","""Help requested.""","""vĂԂŁAĂB"""
"""""","""\nNOTE: the -p option has changed. ""","""\nNOTE: -pIvV͕ω܂B"""
"""""","""It now expects a parameter specifying a range of attributes ""","""͌݁A܂܂ȑw肷p^\z܂B"""
"""""","""to list with the predictions. Use '-p 0' for none.""","""\ŋLڂ邽߂ɁB Ȃɂ'-p0'gpĂB"""
"""""","""No training file and no object ""","""g[jOt@CȂĂ܂IuWFNg܂B"""
"""""","""input file given.""","""^ꂽt@C͂ĂB"""
"""""","""No training file and no test file given.""","""g[jOt@CȂăeXg͑S^ԂŃt@C܂B"""
"""""","""Can't use both train and model file ""","""gṕAƂɃt@CPāAf邱Ƃł܂B"""
"""""","""unless -p specified.""","""-pw肵ȂȂB"""
"""""","""Can only do class based evaluation on the ""","""NXɊÂĂ]ł邾łB"""
"""""","""training data""","""g[jOf[^"""
"""""","""Can't load a clusterer and do class based ""","""clustererςݍŁAÂNXł܂B"""
"""""","""evaluation""","""]"""
"""""","""Class is out of range!""","""NX͔͈͂EĂ܂!"""
"""""","""Class must be nominal!""","""NX͖ڏłɈႢ܂!"""
"""""","""ClusterEvaluation: """,""""""
"""""","""\n\n=== Clustering stats for training data ===\n\n""","""\n\n=== g[jOf[^̂߂̃NX^Ov===\n\n"""
"""""","""\n\n=== Clustering stats for testing data ===\n\n""","""\n\n=== eXgf[^̂߂̃NX^Ov===\n\n"""
"""""","""Can't find class with name ""","""OŃNX邱Ƃł܂B"""
"""""",""" must be a distrinbution """,""" adistrinbutionłȂ炻Ȃ΂Ȃ܂B"""
"""""","""clusterer.""","""clustererB"""
"""""","""Can't parse given options in ""","""̃IvVlāA͂邱Ƃł܂B"""
"""""","""cross-validation!""","""Ă鍇@!"""
"""""",""" fold CV Log Likelihood: """,""" CV Log Likelihood܂d˂Ă: """
"""""","""Clustered Instances\n""","""QĂ\n"""
"""""","""\nUnclustered Instances : ""","""\͗nUnclustered܂: """
"""""","""\n\nLog likelihood: ""","""n~\nLog: """
"""""","""Can't open file ""","""ˊO̓t@C邱Ƃł܂B"""
"""""","""Unable to cluster instance\n""","""\nQ邱Ƃł܂B"""
"""""",""" Unclustered """,""" Unclustered܂B"""
"""""","""\n\nGeneral options:\n\n""","""n~\nGeneralIvV: \n\n"""
"""""","""-t <name of training file>\n""","""-t<g[jOt@C̖O>\n"""
"""""","""\tSets training file.\n""","""\tSetsg[jOt@C\n"""
"""""","""-T <name of test file>\n""","""-T<eXgt@C̖O>\n"""
"""""","""-l <name of input file>\n""","""-l<̓t@C̖O>\n"""
"""""","""\tSets model input file.\n""","""\tSetsf̓t@C\n"""
"""""","""-d <name of output file>\n""","""-d<o̓t@C̖O>\n"""
"""""","""\tSets model output file.\n""","""\tSetsfo̓t@C\n"""
"""""","""-p <attribute range>\n""","""-p<͈>\n"""
"""""","""\tOutput predictions. Predictions are for ""","""\tOutput\B \܂B"""
"""""","""training file""","""g[jOt@C"""
"""""","""\n\tif only training file is specified,""","""t@CP邾ł\n\tifw肳܂B"""
"""""","""\n\totherwise predictions are for the test file.""","""\n\͗\totherwise܂BeXgt@Ĉ߂ɁA܂B"""
"""""","""\n\tThe range specifies attribute values to be output""","""n~\tTheA͈͂́Ao͂ɂȂ悤ɑlw肵܂B"""
"""""","""\n\twith the predictions. Use '-p 0' for none.\n""","""\n\͗\twith܂B Ȃɂ'-p0'gpĂA\n"""
"""""","""-x <number of folds>\n""","""-x<܂ڂ̐>\n"""
"""""","""\tOnly Distribution Clusterers can be cross ""","""\tOnly Distribution Clusterers͌Ăꍇ܂B"""
"""""","""validated.\n""",""".. \nLɂ܂B"""
"""""","""-s <random number seed>\n""","""-s<q>\n"""
"""""","""\tSet class attribute. If supplied, class is ignored""","""tSet̃NXʂƍl\B ȂANX𖳎܂B"""
"""""","""\n\tduring clustering but is used in a classes to""","""AQ\n~tduringa钆ẪRlłB"""
"""""","""\n\tclusters evaluation.\n""","""n~\tclusters]\n"""
"""""","""The first argument must be the name of a ""","""ŏ̋c_a̖OłɈႢ܂B"""
"""""","""clusterer""",""""""
"""""","""Dumping ""","""_sO"""
"""""","""Cutting (leaf add) ""","""ؒf(t͉܂) """
"""""","""Node is best""","""m[h͍łǂłB"""
"""""","""categoryUtility: No children!""","""categoryUtility: q܂!"""
"""""","""getProbability: attribute is not nominal""","""getProbability: ͖ڏł͂܂B"""
"""""","""getStandardDev: attribute is not numeric""","""getStandardDev: ͐lł͂܂B"""
"""""","""assignClusterNums: tree not built correctly!""","""assignClusterNums: ؂͐Ă܂ł!"""
"""""","""Cluster ""","""NX^"""
"""""",""" [label=""""",""" ux=AvAv"""
"""""","""leaf ""","""t"""
"""""","""node ""","""m[h"""
"""""","""shape=box style=filled ""","""̃X^C`==͂ςɂȂ܂B"""
"""""","""data =\n""","""f[^=\n"""
"""""","""\tAcuity.\n""","""\. \ntAcuity܂B"""
"""""","""-A <acuity>""","""-A<s>"""
"""""","""\tCutoff.\n""","""\. \ntCutoff܂B"""
"""""","""-C <cutoff>""","""-C<؂>"""
"""""","""set the minimum standard deviation for numeric attributes""","""lɍŒEݒ肵ĂB"""
"""""","""set the category utility threshold by which to prune nodes""","""m[h𙒒肷JeS[eBeB~ݒ肵ĂB"""
"""""","""save instance information for visualization purposes""","""zړÎ߂̃CX^XۑĂB"""
"""""","""Cobweb hasn't been built yet!""","""N̑͂܂ĂĂ܂!"""
"""""","""Number of merges: ""","""A܂: """
"""""","""\nNumber of splits: ""","""Ҋ\nNumber: """
"""""","""digraph CobwebTree {\n""","""ACobwebTree{\n"""
"""""","""Cluster empty!""","""̏ԂŁANX^OĂ!"""
"""""","""No model clusterer set""","""ǂȃfclustererZbg܂łB"""
"""""","""Cluster data using expectation maximization""","""ҍő剻gpāAf[^QĂB"""
"""""","""\tnumber of clusters. If omitted or""","""NX^\tnumberB ܂͏ȗB"""
"""""","""\n\t-1 specified, then cross ""","""ɁAn~t-1~w肳ĂāAĂ܂B"""
"""""","""validation is used to\n\tselect the ""","""@\n\tselect܂Ŏgp܂B"""
"""""","""number of clusters.""","""NX^̐B"""
"""""","""\tmax iterations.\n(default 100)""","""\tmaxJԂ\n(ftHg100)"""
"""""","""\trandom number seed.\n(default 1)""","""\trandom̎q\n(ftHg1)"""
"""""","""\tverbose.""","""\tverboseB"""
"""""","""set number of clusters. -1 to select number of clusters ""","""NX^̐ݒ肵ĂB -1 NX^̐I邽߂"""
"""""","""automatically by cross validation.""","""Iɍ@ɌĂB"""
"""""","""Number of clusters must be > 0. (or -1 to ""","""Number of clusters must be > 0. (-1"""
"""""","""select by cross validation).""","""Ă鍇@ɂIA)"""
"""""","""maximum number of iterations""","""ő吔̌JԂ"""
"""""","""Maximum number of iterations must be > 0!""",""""""
"""""",""" mean: """,""" : """
"""""",""" diff: """,""" ft: """
"""""",""" stdv: """,""""""
"""""","""diff*diff/(2*stdv*stdv): ""","""ft*ft/(2*stdv*stdv): """
"""""","""No clusterer built yet!""","""clusterer͑S܂ĂĂ܂ł!"""
"""""","""\nEM\n==\n""",""""""
"""""","""\nNumber of clusters selected by cross validation: ""","""Ă鍇@őIꂽNX^\nNumber: """
"""""","""\nNumber of clusters: ""","""NX^\nNumber: """
"""""","""Clust: """,""""""
"""""",""" att: """,""""""
"""""","""Inst ""","""Inst"""
"""""",""" Class """,""" NX"""
"""""","""Restarting after CV training failure (""","""CVg[jǑ̏̌ɍĊJA("""
"""""","""Restarting after CV testing failure (""","""CVeXǧ̏̌ɍĊJA("""
"""""",""" clusters""",""" NX^"""
"""""","""# clust: """,""""""
"""""",""" Fold: """,""" ܂: """
"""""",""" Loglikely: """,""""""
"""""","""==============\n# clust: ""","""==============\n#clust: """
"""""",""" Mean Loglikely: """,""" Loglikely͈Ӗ܂: """
"""""","""Number of clusters: ""","""NX^̐: """
"""""","""Haven't generated any clusters!""","""ǂȃNX^Ă܂!"""
"""""","""Cluster : ""","""NX^: """
"""""","""Seed: ""","""q: """
"""""","""Number of instances: ""","""CX^X̐: """
"""""","""\nNumber of atts: ""","""atts\nNumber: """
"""""","""Loglikely: """,""""""
"""""","""Restarting after training failure""","""sPɁAĊJ܂B"""
"""""","""Reducing the number of clusters""","""NX^ɂĐ炷ƁB"""
"""""","""Farthest First Traversal Algorithm""","""łŏ̏cfASY"""
"""""","""Cluster data using the FarthestFirst algorithm""","""FarthestFirstASYgpāAf[^QĂB"""
"""""","""Clustering Time = ""","""NX^O="""
"""""","""\n FarthestFirst\n==============\n""",""""""
"""""","""\nCluster centroids:\n""","""\nCluster}S: \n"""
"""""","""no clusterer has been set yet.""","""clusterer͑S܂ݒ肳Ă܂B"""
"""""","""Can't set the number of clusters to generate - ""","""NX^̐ݒ肷邱ƂłȂA-"""
"""""","""wrapped clusterer does not support this facility.""","""ꂽclusterer͂̎{݂x܂B"""
"""""","""No clusterer has been set""","""clusterer͑Sݒ肳Ă܂B"""
"""""","""MakeDensityBasedClusterer: \n\nWrapped clusterer: """,""""""
"""""","""\nFitted estimators (with ML estimates of variance):\n""","""\͌ςl(ωMLς肪): \nnFitted܂B"""
"""""","""\nCluster: """,""""""
"""""",""" Prior probability: """,""" Om: """
"""""","""Attribute: """,""": """
"""""",""" StdDev = """,""" StdDev="""
"""""","""set minimum allowable standard deviation""","""ŏ̋ełW΍ݒ肵ĂB"""
"""""","""\tminimum allowable standard deviation ""","""\tminimum̋ełW΍"""
"""""","""for normal density computation ""","""ʏ̖xvẐ߂"""
"""""","""\n\t(default 1e-6)""","""\n\t(ftHg1e-6)"""
"""""","""\tClusterer to wrap. (required)\n""","""ւ\tClustererB (Kv)łB\n"""
"""""","""\nOptions specific to clusterer ""","""clustererɓ\nOptions"""
"""""","""A clusterer must be specified with the -W option.""","""-WIvVclustererw肵Ȃ΂Ȃ܂B"""
"""""","""Cluster data using the k means algorithm""","""kgpNX^f[^ASYӖ܂B"""
"""""","""Can't handle string attributes!""","""XgOƂł܂!"""
"""""","""\tnumber of clusters. (default = 2).""","""NX^\tnumberB (ftHg=2)."""
"""""","""\trandom number seed.\n (default 10)""","""\trandom̎q\n(ftHg10)"""
"""""","""set number of clusters""","""NX^̐ݒ肵ĂB"""
"""""","""Number of clusters must be > 0""",""""""
"""""","""random number seed""","""q"""
"""""","""\nkMeans\n======\n""",""""""
"""""","""\nNumber of iterations: ""","""\nJԂ: """
"""""","""Within cluster sum of squared errors: ""","""NX^ł̓덷̍v: """
"""""","""\n\nCluster centroids:\n""","""\n\nNX^̏dS: \n"""
"""""","""\nCluster ""","""\nCluster"""
"""""","""Mean/Mode: ""","""/[h: """
"""""","""\n\tStd Devs:  ""","""\n\tW΍: """
"""""","""@attribute""",""""""
"""""","""integer""",""""""
"""""","""real""",""""""
"""""","""Couldn't compress nominal attribute value -""","""`lkł܂ł -"""
"""""","""A nominal attribute (""","""` ("""
"""""",""") cannot""",""") """
"""""",""" have duplicate labels (""","""dx܂("""
"""""",""" searching uncompressed.""",""" kTĂ܂"""
"""""","""UNKNOWN""","""m"""
"""""","""Can only remove value of""","""l菜Ƃł邾łB"""
"""""","""nominal or string attribute!""","""ڏォXgO!"""
"""""","""Couldn't compress string attribute value -""","""XgOlk邱ƂłȂA-"""
"""""",""" storing uncompressed.""",""" i[͉𓀂܂B"""
"""""","""Can only set values for nominal""","""ڏŒlݒ肷邱Ƃł邾łB"""
"""""",""" or string attributes!""",""" ܂́Ał!"""
"""""","""Can only format date values for date""","""`t̒l̓t邱Ƃł܂B"""
"""""","""Can only parse date values for date""","""t̓t̒l𕪐͂邱Ƃł邾łB"""
"""""",""" attributes!""",""" !"""
"""""","""ordering""","""܂B"""
"""""","""averageable""","""u-\v"""
"""""","""zeropoint""",""""""
"""""","""regular""","""ʏ"""
"""""","""symbolic""","""V{bN"""
"""""","""ordered""","""܂B"""
"""""","""modulo""","""@"""
"""""","""A symbolic attribute cannot be""","""V{bNȑ͂ł͂܂B"""
"""""",""" regular""",""" ʏ"""
"""""","""An averagable attribute must be""","""ω\͂łɈႢ܂B"""
"""""","""A zeropoint attribute must be""","""zeropoint͂łɈႢ܂B"""
"""""",""" ordered""",""" ܂B"""
"""""","""Not a valid attribute weight: '""","""LȑdłȂ: '"""
"""""","""range""","""͈"""
"""""","""[-inf,20)""","""[-inf,20)"""
"""""","""(5,inf]""","""(5,inf]"""
"""""","""Expected opening brace on range,""","""͈͂ŏ߂̎x\z܂B"""
"""""","""Expected lower bound in range,""","""͈͂ŉE\z܂B"""
"""""","""Expected comma in range,""","""͈͂ŃR}\z܂B"""
"""""","""-inf""",""""""
"""""","""+inf""","""+inf"""
"""""","""inf""",""""""
"""""","""Expected upper bound in range,""","""͈͂ŏ҂܂B"""
"""""",""" found: '""",""" ݗ܂: '"""
"""""","""Expected closing brace on range,""","""xɔȂ\zāAyłB"""
"""""","""Expected end of range string,""","""͈̓XgO̒[\z܂B"""
"""""",""" found: """,""" ݗ܂: """
"""""","""IOException reading attribute range""","""ǂIOExceptionyт܂B"""
"""""",""" string: """,""" XgO: """
"""""","""Upper bound (""","""A("""
"""""",""") on numeric range is""",""") lɊւāA͈͂͂łB"""
"""""",""" less than lower bound (""",""" EȉA("""
"""""","""yyyy-MM-dd HH:mm:ss""","""mm dd HHyyyyĂA: mm: ss"""
"""""","""2001-04-04 14:13:55""",""""""
"""""","""Test date = ""","""eXgt="""
"""""","""Date now = ""","""A=̓tĂB"""
"""""","""Value of ""position"": ""","""uuʒuvv̒l: """
"""""","""Copy is the same as original: ""","""Rs[͓炢IWił邱Ƃ̌`œł: """
"""""","""Index of attribute ""weight"" (should be -1): ""","""uudvv(-1łׂł)̃CfbNX: """
"""""","""Index of value ""first"" of ""position"" (should be 0): ""","""uuŏɁvvuuʒuvv(0łׂł)̉l̃CfbNX: """
"""""","""""position"" is numeric: ""","""uuʒuvv͐lł: """
"""""","""""position"" is nominal: ""","""uuʒuvv͖ڏł: """
"""""","""""position"" is string: ""","""uuʒuvv̓XgOł: """
"""""","""Name of ""position"": ""","""uuʒuvv̖O: """
"""""","""Number of values for ""position"": ""","""uuʒuvvւ̒l̐: """
"""""","""Value ""","""l"""
"""""","""""position"" is numeric""","""uuʒuvv͐lłB"""
"""""","""""position"" is nominal""","""uuʒuvv͖ڏłB"""
"""""","""""position"" is string""","""uuʒuvv̓XgOłB"""
"""""","""""position"" is date""","""uuʒuvv͓tłB"""
"""""","""""position"" has unknown type""","""uuʒuvvɂ́Am̃^Cv܂B"""
"""""","""Copy with class value set to ""second"": ""","""KlRs[́uu2ԖڂɁvvɃZbg܂: """
"""""","""first set of options is null!""","""ŏ̃Zbg̃IvV̓kł!"""
"""""","""second set of options is null!""","""2Ԗڂ̃Zbg̃IvV̓kł!"""
"""""","""First set: ""","""܂ŏɁAZbgĂ: """
"""""","""Second set: ""","""2ԖڂɁAZbgĂ: """
"""""","""options differ in length""","""IvV͒ɂĈقȂ܂B"""
"""""","""problem found!\n""","""\n܂B"""
"""""","""\tFirst set: ""","""\tFirst̓Zbg܂: """
"""""","""\tSecond set: ""","""\tSecond̓Zbg܂: """
"""""","""OptionHandler: """,""""""
"""""","""Default options:""","""ȗ̃IvV:"""
"""""","""User options:""","""[UEIvV:"""
"""""","""Setting user options...""","""[UEIvVݒ肵܂c"""
"""""","""Remaining options:""","""cĂIvV:"""
"""""","""Getting canonical user options:""","""邱Ƃ̐ȃ[UEIvV:"""
"""""","""Setting canonical user options...""","""ȃ[UEIvVݒ肵܂c"""
"""""","""Checking canonical user options...""","""ȃ[UEIvV`FbN܂c"""
"""""","""Resetting to default options...""","""ȗ̃IvVɁAZbg܂B"""
"""""","""Checking default options match previous default...""","""ƍȗ̃IvV͑ÕftHgɍ܂c"""
"""""","""Please give a class name with -W option""","""-WIvVƋɃNX^ĂB"""
"""""","""Couldn't find OptionHandler with name ""","""OOptionHandler邱Ƃł܂łB"""
"""""","""Chi-squared probability: ""","""L[œ悳ꂽm: """
"""""","""Chi-squared value: ""","""L[œ悳ꂽl: """
"""""","""Cochran's criterion fullfilled: ""","""RN̕]fullfilled܂: """
"""""","""Cramer's V: ""","""N[}[V: """
"""""","""Entropy of first row: ""","""ŏ̗̃Ggs[: """
"""""","""Entropy conditioned on columns: ""","""Ggs[̓RƂ܂: """
"""""","""Entropy conditioned on rows: ""","""Ggs[͗Ƃ܂: """
"""""","""Entropy conditioned on rows (with Laplace): ""","""Ggs[͗(vX)Ƃ܂: """
"""""","""Entropy of rows: ""","""̃Ggs[: """
"""""","""Entropy of columns: ""","""R̃Ggs[: """
"""""","""Gain ratio: ""","""䗦lĂ: """
"""""","""Negative log2 of multiple hypergeometric probability: ""","""hypergeometricm̔ےIlog2: """
"""""","""Symmetrical uncertainty: ""","""Ώ̂̕sm: """
"""""","""Tau value: ""","""^Eql: """
"""""","""Matrix with empty row and column: ""","""̗ƃR}gNX: """
"""""","""Reduced matrix: ""","""}gNX܂: """
"""""","""No data set loaded. Data set has to be in ARFF format.""","""f[^Zbg͑S[h܂łB ARFF`ɂ̓f[^ZbgȂ΂Ȃ܂B"""
"""""","""Cannot create output file. Standard out is used.""","""o̓t@C쐬邱Ƃł܂B W̃AEg͎gpĂ܂B"""
"""""","""File deleted.""","""t@C͍폜܂"""
"""""","""File exists and will be overridden.""","""t@Ĉ݂ŁC㏑܂"""
"""""","""File already exists.""","""t@C͊ɑ݂Ă܂"""
"""""","""File prefix and/or directory could not have been set.""","""t@CړA/܂́AfBNgݒ肷邱Ƃł܂ł"""
"""""","""Setting File as source not supported""","""File\[XƂݒ̓T|[gĂ܂"""
"""""","""Setting InputStream as source not supported""","""InputStream\[XƂݒ̓T|[gĂ܂"""
"""""","""Writing to a file not supported""","""T|[gĂȂt@Cɏݒ"""
"""""","""Writing to an outputstream not supported""","""T|[gĂȂoutputstreamɏݒ"""
"""""","""A structure cannot be set up during an active incremental saving process.""","""ANeBuȒIۑɍ\ݒł܂ł"""
"""""","""No Incremental saving possible.""","""Iۑ͕s\ł"""
"""""","""Saving in a file not supported.""","""t@Cւ̕ۑ̓T|[gĂ܂"""
"""""","""Reads a source that is in arff (attribute relation file format) ""","""arff`̃f[^Zbgǂݍ (֌Wt@C`) """
"""""","""Unable to determine structure as arff.""","""arffƂč\肷邱Ƃł܂"""
"""""","""Usage:\n\tArffLoader <file.arff>\n""","""p@: \n\tArffLoader <file.arff>\n"""
"""""","""Writes to a destination that is in arff (attribute relation file format) ""","""arff`ŕۑ(֌Wt@C`) """
"""""","""format. """,""" """
"""""","""\n\nArffSaver options:\n\n""","""\n\nArffSaverIvV: \n\n"""
"""""","""Reads a file that is C45 format. Can take a filestem or filestem ""","""C45`̃t@Cǂݍ"""
"""""","""with .names or .data appended. Assumes that path/<filestem>.names and ""","""..names.dataǉĂāB Ă̌oH/<filestem>.names肷B"""
"""""","""path/<filestem>.data exist and contain the names and data ""","""oH/<filestem>.data݂͑ĂāAOƃf[^܂ł܂B"""
"""""","""respectively.""","""ꂼB"""
"""""","""C4.5 data files""","""C4.5`̃f[^t@C"""
"""""","""File not found : ""","""t@C܂: """
"""""","""No source has beenspecified""","""\[X肳Ă܂"""
"""""","""nominal value not declared in """,""""""
"""""","""header :""","""wb_[:"""
"""""",""" column """,""" """
"""""","""Shouldn't get here""","""ɓׂł͂܂B"""
"""""","""premature end of line. Expected ""","""ȍsB \z܂B"""
"""""","""attribute type.""","""^CvʂƍlĂB"""
"""""","""ignore""",""""""
"""""","""continuous""","""A"""
"""""","""Class""","""NX"""
"""""","""Usage:\n\tC45Loader <filestem>[.names | data]\n""","""p@: \n\tC45Loader <filestem>[.names| data]\n"""
"""""","""Writes to a destination that is in the format used by the C4.5 algorithm.\nTherefore it outputs a names and a data file.""","""C4.5ASYł̌`ŏ. \n.namest@C.datat@Co͂܂D"""
"""""","""C4.5 file format""","""C4.5t@C`"""
"""""","""No class specified. Last attribute is used as class attribute.""","""NXł܂ Ō̑NXƂĎgp܂B"""
"""""","""To save in C4.5 format the class attribute cannot be numeric.""","""C4.5`ŕۑɂ̓NXl^łĂ͂Ȃ܂D"""
"""""","""C4.5 format requires two files. Therefore no output to standard out can be generated.\nPlease specifiy output files using the -o option.""","""C4.5`2̃t@CKvƂ܂D̂߁CWo͂ɂ͉o͂܂. -o IvVgpďo̓t@Cw肵Ă\n"""
"""""","""Cannot create data file, only names file created.""",""".datat@C쐬ł܂łD.namest@C쐬܂D"""
"""""","""The input file""","""̓t@C"""
"""""","""-i <the input file>""","""-i <̓t@C>"""
"""""","""The output file""","""o̓t@C"""
"""""","""-o <the output file>""","""-o <o̓t@C>"""
"""""","""The class index""","""NX̗ԍ"""
"""""","""-c <the class index>""","""-c <NX̗ԍ>"""
"""""","""No data set loaded. Data set has to be arff format.""","""f[^Zbg͓ǂݍ݂ł܂łDf[^Zbgarff`łȂ΂Ȃ܂"""
"""""","""No data set to save.""","""ۑf[^Zbg܂"""
"""""","""Cannot create output file.""","""o̓t@C쐬邱Ƃł܂B"""
"""""","""Invalid class index""","""ȃNXCfbNX"""
"""""","""\n\nC45Saver options:\n\n""","""\n\nC45SaverIvV: \n\n"""
"""""","""Reads a source that is in comma separated or tab separated format. ""","""R}^uŋ؂ꂽ`̃\[Xǂݍ"""
"""""","""Assumes that the first row in the file determines the number of ""","""t@C̍ŏ̍s𑮐"""
"""""","""and names of the attributes.""","""ƌȂ܂"""
"""""","""dummy""","""_~[""
"""""","""Wrong attribute type!!!""","""Ԉ^Cv!!!"""
"""""","""CSVLoader can't read data sets incrementally.""","""CSVLoader̓f[^Zbg𒀎Iɓǂݍ݂ł܂"""
"""""","""wrong number of values. Read ""","""Ԉ̒lB ǂłB"""
"""""",""", expected """,""", \z܂B"""
"""""","""current shouldn't be null in checkStructure""","""dcheckStructureŃkłׂł͂܂B"""
"""""","""Wrong object type in checkStructure!""","""checkStructure̊ԈIuWFNgE^Cv!"""
"""""","""\\.[cC][sS][vV]$""",""""""
"""""","""Usage:\n\tCSVLoader <file.csv>\n""","""p@: \n\tCSVLoader <file.csv>\n"""
"""""","""Writes to a destination that is in csv format""","""csv`wʒuɏ"""
"""""","""CSV file: comma separated files""","""CSVt@C: R}؂̃t@C"""
"""""","""\n\nCSVSaver options:\n\n""","""\n\nCSVSaverIvV: \n\n"""
"""""","""Loaded driver: ""","""hCo[ǂݍ: """
"""""","""nominalToStringLimit""",""""""
"""""","""Reads Instances from a Database""","""f[^x[X̓ǂݍ"""
"""""","""[fF][rR][oO][mM]""",""""""
"""""","""FROM""",""""""
"""""","""[sS][eE][lL][eE][cC][tT]""",""""""
"""""","""The query that should load the instances.""","""ǂݍނ߂̗v"""
"""""","""\n The query has to be of the form SELECT <column-list>|* FROM <table> [WHERE <conditions>]""","""₪tH[SELECT<RXg悤ɎĂ\n>|<e[u>*AǂA<>"""
"""""","""For incremental loading a unique identiefer has to be specified.""","""̃[fBOƂāAj[Nidentiefer͎w肳Ȃ΂Ȃ܂B"""
"""""","""\nIf the query includes all columns of a table (SELECT *...) a primary key""","""\̓e[u(SELECT*c)a\IɊւ邷ׂẴR킹鎿CN[hnIf܂B"""
"""""","""\ncan be detected automatically depending on the JDBC driver. If that is not possible""","""\ncan܂BJDBChCo[ɗāAIɌoĂB ꂪ\łȂȂ"""
"""""","""\nspecify the key columns here in a comma separated list.""","""\͂AR}̐؂藣ꂽXg̒̎vȃRnspecify܂B"""
"""""","""FROM ""","""""",""""""
"""""","""SELECT *""","""""",""""""
"""""",""" ORDER BY ""","""""",""""""
"""""","""SELECT""","""""",""""""
"""""","""SELECT LIMIT ""","""""",""""""
"""""",""" LIMIT 1 OFFSET ""","""""",""""""
"""""",""" LIMIT ""","""""",""""""
"""""","""Cannot count results tuples.""","""tuples𐔂邱Ƃł܂B"""
"""""","""Cannot mix getting instances in both incremental and batch modes""","""̗ႪɂȂāAob`E[h邱Ƃł܂B"""
"""""","""Table does not exist.""","""e[u݂͑Ă܂B"""
"""""","""Incremental loading not supported for that DBMS. Pseudoincremental mode is used if you use incremental loading.\nAll rows are loaded into memory once and retrieved incrementally from memory instead of from the database.""","""DBMŜ߂ɎxȂ̃[fBOB Ȃ̃[fBOgpȂAPseudoincremental[h͎gpĂ܂B\nAlĺAxɃ[hāAf[^x[X̑Ƀ瑝Č܂B"""
"""""","""SELECT COUNT(DISTINCT( ""","""""",""""""
"""""",""" )) FROM ""","""""",""""""
"""""","""Count for nominal values cannot be calculated. Attribute ""","""zʉî߂̃JEgɂČvZ邱Ƃł܂B """
"""""",""" treated as String.""",""" StringƂĈ܂B"""
"""""","""SELECT DISTINCT ( ""","""""",""""""
"""""",""" ) FROM ""","""""",""""""
"""""","""Nominal values cannot be retrieved""","""zʉi邱Ƃł܂B"""
"""""","""Select * from Results0""","""""","""Select * from Results0"""
"""""","""\n\nDatabaseLoader options:\n""","""\n\nDatabaseLoaderIvV: \n"""
"""""","""No source database has been specified""","""\[Xf[^x[Xw肳Ă܂"""
"""""","""Cannot mix getting Instances in both incremental and batch modes""","""InstancesɂȂāAob`E[h邱Ƃł܂B"""
"""""","""A unique order cannot be detected automatically.\nYou have to use SELECT * in your query to enable this feature.\nMaybe JDBC driver is not able to detect key.\nDefine primary key in your database or use -P option (command line) or enter key columns in the GUI.""","""IɃj[NȃI[_[o邱Ƃł܂B\nYoúA̓\ɂ̂ɂȂ̎SELECT*gpȂ΂Ȃ܂B\nMaybe JDBChCo[́AȂ̃f[^x[XɃL[\nDefinȇ̃L[o邱ƂłȂAGUI-PIvV(R}hC)G^[L[Rgp邱Ƃł܂B"""
"""""","""Tuple could not be retrieved.""","""Tuple邱Ƃł܂łB"""
"""""","""\tSQL query of the form SELECT <list of columns>|* FROM <table> [WHERE] to execute (default Select * From Results0).""","""tSQL₷R̃tH[SELECT<Xg\>|*FROM<́A(Results0̃ftHgSelect*)s邽߂>WHEREe[ȕɒu܂B"""
"""""","""\tList of column names uniquely defining a DB row (separated by ', ').\n\tUsed for incremental loading.""","""'BDB`R\tListDA(A'A'A). ̃[fBÔ߂\n\tUsedB"""
"""""","""\n\tIf not specified, the key will be determined automatically, if possible with the used JDBC driver.\n\tThe auto ID column created by the DatabaseSaver won't be loaded.""","""L[͎IɒfłƂł傤AÂJDBChCo[ŉ\łȂ\n\tIfw肵Ȃ̂Bn~\tTheADatabaseSaverɂč쐬ꂽIDR̓[hȂł傤B"""
"""""","""-P<list of column names>""","""-P <̖̃Xg>"""
"""""","""\tSets incremental loading""","""\tǂݍ݂̐ݒ"""
"""""","""idColumn""","""idColumn"""
"""""","""Table cannot be dropped.""","""e[uł܂"""
"""""","""Writes to a database""","""f[^x[Xɏ"""
"""""","""Sets the name of the table.""","""e[u̖Oݒ"""
"""""","""If set to true, a primary key column is generated automatically (containing the row number as INTEGER). The name of the key is read from DatabaseUtils (idColumn)""","""{ɐݒ肳ȂAvC}vȃR͎Iɐ܂(INTEGERƂčsԍ܂ł)B L[̖ODatabaseUtilsǂ܂܂B(idColumn)"""
"""""",""" This primary key can be used for incremental loading (requires an unique key). This primary key will not be loaded as an attribute.""",""" ̃[fBO(j[NL[KvƂ)ɂ̃vC}L[gp邱Ƃł܂B ̃vC}L[͑ƂĐςݍ܂Ȃł傤B"""
"""""","""If set to true, the relation name will be used as name for the database table. Otherwise the user has to provide a table name.""","""{ɐݒ肳ƁA֌W̓f[^x[Xe[uɖOƂĎgpł傤B Ȃ΁A[U̓e[u񋟂Ȃ΂Ȃ܂B"""
"""""","""The URL of the database""","""f[^x[XURL"""
"""""","""The user name for the database""","""f[^x[X̂߂̃[U"""
"""""","""The database password""","""f[^x[XpX[h"""
"""""","""Instances have no attribute.""","""CX^Xɂ́A܂B"""
"""""",""" PRIMARY KEY,""",""""""
"""""",""" DATE""",""""""
"""""","""Table cannot be built.""","""e[u\zł܂"""
"""""","""Tuple cannot be inserted.""","""^v}邱Ƃł܂"""
"""""","""Structure(Header Information) has to be set in advance""","""\(wb_[)͂炩߁Aݒ肳Ȃ΂Ȃ܂B"""
"""""","""No instances information available.""","""p\ȃCX^X񂪂܂"""
"""""","""No database has been set up.""","""f[^x[Xݒ肳Ă܂"""
"""""","""\n--- Exception caught ---\n""","""\n--- ߂炦ꂽO---\n"""
"""""","""Message:   ""","""bZ[W: """
"""""","""SQLState:  ""","""SQL: """
"""""","""ErrorCode: ""","""G[R[h: """
"""""","""\tThe name of the table (default: the relation name).""","""tThee[u(ftHg: ֌W)\B"""
"""""","""-T <table name>""","""-T<e[u>"""
"""""","""\tAdd an ID column as primary key. The name is specified in the DatabaseUtils file. The DatabaseLoader won't load this column.""","""\̓vC}L[ƂIDRtAdd܂B ODatabaseUtilst@C̒Ŏw肳܂B DatabaseLoader͂̃R[hȂł傤B"""
"""""","""\tInput file in arff format that should be saved in database.""","""\tInput̓f[^x[XŐߖ񂳂ׂłarff`Ńt@C܂B"""
"""""","""-i<input file name>""","""-i<̓t@C>"""
"""""","""\n\nDatabaseSaver options:\n""","""n~\nDatabaseSaverIvV: \n"""
"""""","""Source file object is null!""","""\[Xt@CIuWFNg̓kł!"""
"""""","""File not found""","""t@C܂"""
"""""","""Could not deserialize instances from this source.""","""̃\[XCX^X𔽘Aڂ邱Ƃł܂łB"""
"""""","""No source has been specified""","""\[Xw肳Ă܂"""
"""""","""Usage:\n\tSerializedInstancesLoader <file>\n""","""p@: \n\tSerializedInstancesLoader <t@C>\n"""
"""""","""Serializes the instances to a file with extension bsi.""","""gbsit@CɃf[^VACY܂"""
"""""","""Serializes the instaces to a file""","""t@CɃf[^VACY܂"""
"""""","""Cannot create a new output file. Standard out is used.""","""Vo̓t@C쐬邱Ƃł܂B W̃AEg͎gpĂ܂B"""
"""""","""Batch and incremental saving cannot be mixed.""","""ob`Ƒ̐ߖ͕Gł邱Ƃł܂B"""
"""""","""No instances to save""","""ۑf[^͂܂"""
"""""","""No output to standard out for serialization.""","""VACŶ߂ɕWo͂ւ̏o͂͂܂"""
"""""","""\n\nSerializedInstancesSaver options:\n\n""","""\n\nSerializedInstancesSaverIvV: \n\n"""
"""""","""deep""","""deep"""
"""""","""Instance has access to a dataset!""","""InstanceNX̓f[^փANZX܂!"""
"""""","""Instance has accesss to a dataset!""","""InstanceNX̓f[^փANZX܂!"""
"""""","""Can't insert attribute: index out ""","""}s\: CfbNX͈͊O"""
"""""","""Class is not set!""","""NX͐ݒ肳Ă܂!"""
"""""","""Attribute neither nominal nor string!""","""͖`^ł^ł܂!"""
"""""","""Value not defined for given nominal attribute!""","""w̖`̒lƂČł܂!"""
"""""","""Attribute isn't nominal, string or date!""","""͖`^E^Et^ł܂!"""
"""""","""\nIncluding the class""","""\nNX܂"""
"""""","""\nExcluding the class""","""\nNX܂܂Ȃ"""
"""""","""comparing 1. instance with 1.: ""","""r1 1.ňȉ؂ĂB """
"""""","""comparing 1. instance with 2.: ""","""r1 2.ňȉ؂ĂB """
"""""","""comparing 2. instance with 1.: ""","""r2 1.ňȉ؂ĂB """
"""""","""@relation""","""@relation"""
"""""","""@data""","""@data"""
"""""","""Capacity has to be positive!""","""eʂ͗złȂ΂Ȃ܂!"""
"""""","""shallow""",""""""
"""""","""Parameters first and/or toCopy out ""","""p^A1ԖځA/܂́AtoCopyAEg"""
"""""","""of range""","""͈͂ɂ"""
"""""","""cleanse""","""􂢂܂B"""
"""""","""Can't delete class attribute""","""NX폜邱Ƃł܂B"""
"""""","""Instances: attribute must be numeric to compute kth-smallest value.""","""CX^X: ́AkthłlvZ邽߂ɐlłȂ΂Ȃ܂B"""
"""""","""Instances: value for k for computing kth-smallest value too large.""",""": kthłlvZɂ́A傫߂k̂߂̒lB"""
"""""",""" not found""",""" ܂B"""
"""""","""weights.length != numInstances.""","""weights.length!=numInstancesB"""
"""""","""Weights have to be positive.""","""d͐ϋɓIłȂ΂Ȃ܂B"""
"""""","""Invalid class index: ""","""̃NX͍܂: """
"""""","""Class index is negative (not set)!""","""NXCfbNX͕ł(Zbg܂)!"""
"""""","""Number of folds must be at least 2!""","""܂ڂ̐͏ȂƂ2łɈႢ܂!"""
"""""","""Can't have more folds than instances!""","""葽̐܂ڂƂł܂!"""
"""""","""Can't compute variance because attribute is ""","""vẐŁAωvZ邱Ƃł܂B"""
"""""","""not numeric!""","""lłȂ!"""
"""""","""Relation Name:  ""","""֌W: """
"""""","""Num Instances:  ""","""CX^X: """
"""""","""Num Attributes: """,""": """
"""""","""Type""","""^Cv"""
"""""","""Int""",""""""
"""""","""Real""",""""""
"""""","""Unique""","""B"""
"""""","""Dist""",""""""
"""""","""Nom""","""`^"""
"""""","""Num""","""l^"""
"""""","""Dat""",""""t^""
"""""","""Str""","""^"""
"""""","""no header information available""","""p\ȃwb_[񂪂܂B"""
"""""","""index number expected""","""҂ꂽw"""
"""""","""indices have to be ordered""","""CfbNXXg͒Ȃ΂Ȃ܂B"""
"""""","""index out of bounds""","""OɍĂB"""
"""""","""not a valid value""","""LlłȂ"""
"""""","""nominal value not declared in header""","""wb_[Ő錾Ȃzʉi"""
"""""","""number expected""","""\zꂽ"""
"""""","""unparseable date: ""","""񕪐͉\t: """
"""""","""unknown attribute type in column ""","""R̖m̑^Cv"""
"""""","""not a valid date format""","""Lȓť`łȂ"""
"""""","""no valid attribute type or invalid ""","""Lȑ^CvłȂal܂B"""
"""""","""enumeration""",""""""
"""""","""{ expected at beginning of enumeration""","""񋓂̎n߂ɗ\zꂽ{"""
"""""","""} expected at end of enumeration""","""} 񋓂̏Iɗ\z܂B"""
"""""","""no nominal values found""","""ȂzʉiS"""
"""""","""keyword ""","""L[[h"""
"""""",""" expected""",""" \z܂B"""
"""""","""no attributes declared""","""͑S錾܂łB"""
"""""",""", read """,""", ǂłB"""
"""""","""end of line expected""","""\zꂽs"""
"""""","""premature end of line""","""ȍs"""
"""""","""premature end of file""","""ȃt@C̏I"""
"""""","""Instance sets must be of the same size""","""CX^XZbg͓TCŶ̂łɈႢ܂B"""
"""""","""Usage: Instances [<filename>]""","""p@: (<t@C>)"""
"""""","""first_value""","""_ŏɁAl"""
"""""","""second_value""","""2Ԗڂ_l"""
"""""","""nominal_attribute""","""`"""
"""""","""numeric_attribute""","""l"""
"""""","""test_set""","""eXgf[^Zbg"""
"""""","""\nSet of instances created from scratch:\n""","""ŏ쐬ꂽ\nSet: \n"""
"""""","""\nFirst five instances from file:\n""","""nFirst5t@C؂\: \n"""
"""""","""\nClass index: ""","""\nClass͍܂: """
"""""","""\nClass is nominal: ""","""\nNX͖`^ł: """
"""""","""\nClass is numeric: ""","""\nNX͐l^ł: """
"""""","""\nClass values and labels of instances:\n""","""\nNXlƃf[^̃x: \n"""
"""""","""\tis missing""","""\t͌܂"""
"""""","""\nCreating random weights for instances.""","""\nef[^ւ̃_ȏd݂̐"""
"""""","""Inserted""","""}܂B"""
"""""","""\nSet with inserted attribute:\n""","""\n}ꂽ𔺂W: \n"""
"""""","""\nSet with attribute deleted:\n""","""\n폜ꂽ𔺂W: \n"""
"""""","""\nHeaders equal: ""","""\nwb_[͓ł: """
"""""","""\nData (internal values):\n""","""\nData(̒l): \n"""
"""""","""\nEmpty dataset:\n""","""\nf[^Zbg: \n"""
"""""","""new_name""","""VO"""
"""""","""new_val_name""","""Vl̖O"""
"""""","""\nDataset with names changed:\n""","""\nOύXf[^Zbg: \n"""
"""""","""\nOriginal dataset:\n""","""\ñf[^Zbg: \n"""
"""""","""\nSubset of dataset: ""","""\nf[^Zbg̕W: """
"""""",""" instances from """,""" """
"""""",""". instance""",""".. CX^X"""
"""""","""\nTrain and test folds for 3-fold CV:""","""\n3-fold CV̂߂̌Pƌ؂̕ʂ:"""
"""""","""\nTrain: ""","""\nP: """
"""""","""\nTest: ""","""\neXg: """
"""""","""\nClass name: ""","""\nNX: """
"""""","""\nRandomized dataset:""","""\n_f[^Zbg:"""
"""""","""\nInstances sorted according to first attribute:\n ""","""ŏ̑ɏ]ĕނꂽ\nInstances: \n"""
"""""","""\nInstances and their weights:\n""","""\nef[^Ƃ̏d: \n"""
"""""","""\nSum of weights: ""","""\nd݂̍v: """
"""""","""Usage: Instances <filename>""","""p@: f[^Zbg <t@C>"""
"""""","""Matrix is not symmetric positive definite.""","""}gNX͍EΏ̂̐mł͂܂B"""
"""""","""Incorrect number of weights provided""","""smȐ̏d肪񋟂܂B"""
"""""","""Only one dependent variable allowed""","""ˑϐe1"""
"""""","""left-looking""","""̌܂B"""
"""""","""Matrix must be square.""","""}gNX͐`łɈႢ܂B"""
"""""","""Matrix is singular.""","""}gNX͂܂łB"""
"""""","""sets""","""Zbg"""
"""""","""Array length must be a multiple of m.""","""z̒m̔{łɈႢ܂B"""
"""""",""": expected number of columns""",""": \zꂽ̃R"""
"""""",""": too many rows provided""",""": ܂ɑ̍s񋟂܂B"""
"""""",""": too few matrix elements provided""",""": ܂ɂ킸ȃ}gNXvf񋟂܂łB"""
"""""",""": expected number of rows""",""": \zꂽ̍s"""
"""""","""Line """,""""""
"""""",""": too few rows provided""",""": ܂ɂ킸ȍs񋟂܂łB"""
"""""","""All rows must have the same length.""","""ׂĂ̗ɂ́AȂ΂Ȃ܂B"""
"""""","""Submatrix indices""","""SubmatrixCfbNXXg"""
"""""","""Matrix inner dimensions must agree.""","""}gNX̓̏dv͓ӂȂ΂Ȃ܂B"""
"""""","""blank""",""""""
"""""","""Unexpected EOF on matrix read.""","""}gNX̗̏\ȂEOF͓ǂ݂܂B"""
"""""",""" is too long.""",""" ߂܂B"""
"""""",""" is too short.""",""" Z߂܂B"""
"""""","""Matrix dimensions must agree.""","""}gNX̏dv͓ӂȂ΂Ȃ܂B"""
"""""","""% Rows\tColumns\n""","""%\tColumns\n܂B"""
"""""","""% Matrix elements\n""","""%AMatrixvf\n"""
"""""","""\nIdentity\n""",""""""
"""""","""I(3,5)\n""","""I(3A5)\n"""
"""""","""\nbasic operations - square\n""","""\nbasic--`\n"""
"""""","""A^T\n""","""^T\n"""
"""""","""A+B\n""","""+B\n"""
"""""","""X from A*X=B\n""","""*X=B\nX"""
"""""","""\nbasic operations - non square\n""","""\nbasic--񐳕`\n"""
"""""","""A*B\n""","""*B\n"""
"""""","""\nsqrt (1)\n""","""\nsqrt(1)\n"""
"""""","""\nsqrt (2)\n""","""\nsqrt(2)\n"""
"""""","""sqrt(A)\n""",""""""
"""""","""det(A)\n""",""""""
"""""","""\nEigenvalue Decomposition\n""","""\nEigenvalue\n"""
"""""","""[V,D] = eig(A)""","""VAD=eig(A)"""
"""""","""\nLU Decomposition\n""","""\nLU\n"""
"""""","""[L,U,P] = lu(A)""","""LAUAP=Lu(A)"""
"""""","""\nRegression\n""",""""""
"""""","""ridge = ""","""="""
"""""","""weights = ""","""d="""
"""""","""A.regression(B, ridge)\n""","""ABA(BAɂȂ)\n"""
"""""","""A.regression(B, weights, ridge)\n""","""ABA(BAd͐ɂȂ)\n"""
"""""","""A = new Matrix.read(Reader)\n""","""=VMatrix.read(ǎ)\n"""
"""""","""\nMatlab-Format\n""","""\nMatlab`\n"""
"""""","""[ 1   2;3 4 ]""","""[ 1 2;3 4 ]"""
"""""","""[1 2 3 4;3 4 5 6;7 8 9 10]""",""""""
"""""","""Matlab: """,""""""
"""""","""from Matlab:\n""","""Matlab: \n"""
"""""","""to Matlab:\n""","""Matlab: \n"""
"""""","""Matrix row dimensions must agree.""","""}gNX̏dv͓ӂȂ΂Ȃ܂B"""
"""""","""Matrix is rank deficient.""","""}gNX̓Ns\łB"""
"""""","""Matrix is singular""","""}gNX͂܂łB"""
"""""","""EigenvalueDecomposition: Matrix must be symmetric.""","""EigenvalueDecomposition: }gNX͍EΏ̂łɈႢ܂B"""
"""""","""Number of columns for a: ""","""â߂̃R̐: """
"""""","""Number of rows for a: ""","""â߂̗̐: """
"""""","""a (0, 0): ""","""(0A0): """
"""""","""a transposed:\n ""","""]ڂa: \n"""
"""""","""a * b:\n ""","""*b: \n"""
"""""","""Coefficients of regression of b on r: ""","""rɂb̕ǍW: """
"""""","""Weights: ""","""d: """
"""""","""Coefficients of weighted regression of b on r: ""","""rɂb̉dǍW: """
"""""","""a with (0, 0) set to 6:\n ""","""6ւ(0A0)Zbga: \n"""
"""""","""wrote matrix to ""main.matrix""\n""","""}gNXumain.matrix""v\n܂ŏ܂B"""""""
"""""","""read matrix from ""main.matrix""\n""","""umain.matrix""v\n}gNXǂłB"""""""
"""""","""Not enough memory. Please load a smaller ""","""\ȃłȂB 菬a[hĂB"""
"""""","""dataset or use larger heap size.\n""","""f[^ZbgA 傫R̃TCY\ngpĂB"""
"""""","""- initial JVM size:   ""","""- JVMTCYɓĂ: """
"""""","""- total memory used:  ""","""- L͎gp܂: """
"""""","""- max. memory avail.: ""","""- ő僁vA: """
"""""","""MB\n""",""""""
"""""","""The Java heap size can be specified with the -Xmx option.\n""","""-XmxIvVJavaR̃TCYw肷邱ƂłA\n"""
"""""","""E.g., to use 128MB as heap size, the command line looks like this:\n""","""EBg. R̃TCYƂĂ̎gp128MBւ̃R}hC͂: \nɎĂ܂B"""
"""""","""   java -Xmx128m -classpath ...""",""" java -Xmx128m -classpathc"""
"""""","""OutOfMemory""",""""""
"""""","""Thread""",""""""
"""""","""AWT-EventQueue""",""""""
"""""","""active""","""ANeBu"""
"""""","""sufficient function decrease""","""\ȋ@\"""
"""""","""safe""",""""""
"""""","""reliable""","""Mł"""
"""""","""Minimization Subject to Bounds on the Variables""","""ϐ̗̈Ƃŏ"""
"""""","""An Introduction to Optimization""","""œKւ̏_"""
"""""",""", Prentice-Hall Inc. and Press et al.(1992) """,""""""
"""""","""Machine precision is ""","""}Vx͂łB"""
"""""",""" and zero set to """,""" āAZbgꂽ["""
"""""","""Numeric Recipes in C""","""C̐lVs"""
"""""","""fold:  ""","""܂: """
"""""","""sum:  ""","""v: """
"""""","""stpmax:  ""","""stpmax: """
"""""","""slope:  ""","""X[v: """
"""""","""Gradient and direction orthogonal -- ""","""zƎw--"""
"""""",""": isFixed=""",""": =isFixed܂B"""
"""""",""", grad=""",""", Ɛ="""
"""""",""", direct=""",""", _CNg="""
"""""","""g'*p positive! -- Try to debug from here: line 327.""","""'g'*pϋɓI! -- ȉfobO悤ɂĂB 327𗠑łĂB"""
"""""","""Zero directions for all free variables -- ""","""ׂĂ̎Rύ̂߂̎w̃[킹Ă--"""
"""""","""Min. found with current fixed variables""","""ϐŒ肳ĂdŌꂽ"""
"""""",""" (or all variables fixed). Try to release""",""" (ׂĂ̕ϐC܂B) [XɎ݂ĂB"""
"""""",""" some variables now.""",""" ݂̂̕ϐB"""
"""""","""binding""","""t܂B"""
"""""",""" to lower bound """,""" E"""
"""""",""" to upper bound """,""" """
"""""","""alamin: """,""""""
"""""","""alpha: ""","""At@: """
"""""","""Alpha too small, try again""","""At@A܂ɏAx݂ĂB"""
"""""","""\nLine search iteration: ""","""\nLine͌JԂ{܂: """
"""""","""Too large m_f.  Shrink step by half.""","""傫߂m_fB ŃXebvk߂ĂB"""
"""""","""Wrong starting points, change them!""","""o_s҂ĂAāAςĂ!"""
"""""","""obj. function: ""","""obj@\: """
"""""","""threshold: ""","""~: """
"""""","""Sufficient function decrease (alpha condition): ""","""\ȋ@\(At@): """
"""""","""Increasing derivatives (beta condition): ""","""h(x[^)𑝋܂: """
"""""","""Alpha condition holds, increase alpha... ""","""At@Ԃ͐āA̓At@łc"""
"""""","""Increasing derivatives (beta condition): \n""","""h(x[^)𑝉܂: \n"""
"""""","""newSlope = ""","""newSlope="""
"""""","""Alpha condition holds.""","""At@Ԃ͐܂B"""
"""""","""No feasible lambda: still take""","""\ȃɂ܂: łAĂB"""
"""""",""" alpha=""",""" At@="""
"""""","""Cannot find feasible lambda""","""\ȃɂ邱Ƃł܂B"""
"""""","""-b+sqrt(disc) too large! Set it to MAX_VALUE.""","""-܂Ab+͑Ƃ̂sqrt܂(fBXN)! }bNX_VALUEɂݒ肵ĂB"""
"""""","""Cubic interpolation: \n""","""̂̑}: \n"""
"""""","""disc:   ""","""fBXN: """
"""""","""tmplam:   ""","""tmplam: """
"""""","""alam:   ""","""alam: """
"""""","""Sth. wrong in lnsrch:""","""lnsrchŊԈĂSth:"""
"""""","""Lambda infeasible!(lambda=""","""Ɏss\!A(="""
"""""",""", alpha=""",""", At@="""
"""""",""", upper=""",""", 㑤="""
"""""",""", m_f=""",""""""
"""""",""", fold=""",""", ܂="""
"""""",""", slope=""",""", X[v="""
"""""","""Last stage of searching for beta condition (alam between ""","""Ō̃Xe[Wɂăx[^ԂA(Ԃalam"""
"""""",""" and """,""" """
"""""","""Quadratic Interpolation(QI):\n""","""񎟂̑}(QI): \n"""
"""""","""Last newSlope = ""","""ŌnewSlope="""
"""""","""fhi = ""","""fhi="""
"""""","""flo = ""","""flo="""
"""""","""ldiff = ""","""ldiff="""
"""""","""lincr (using QI) = ""","""lincr(QIgp)="""
"""""","""Beta condition cannot be satisfied, take alpha condition""","""x[^Ԃ𖞂ƂłȂŁABe̓At@ԂłB"""
"""""","""Both alpha and beta conditions are satisfied. alam=""","""At@ƃx[^Ԃ̗ĂAalam="""
"""""","""Fix variable ""","""ϐCĂB"""
"""""",""" to bound """,""" oEh悤"""
"""""",""" from value """,""" l"""
"""""","""Practical Optimization""","""pIȍœK"""
"""""","""\nIteration # ""","""\nIteration#"""
"""""","""Line search ... ""","""𗠑łĂc"""
"""""","""Line search finished.""","""͏I܂B"""
"""""","""\nDeltaX converge: ""","""\nDeltaX͈_ɏW܂܂: """
"""""","""Gradient converge: ""","""z͈_ɏW܂܂: """
"""""","""dg'*dx=""","""'dg'*dx="""
"""""","""Test any release possible ...""","""\Ȃ郊[XeXgĂc"""
"""""","""] not fixed on the""","""] Œ肳Ă܂B"""
"""""",""" bounds where it should have been!""",""" ꂪׂł̈!"""
"""""","""Variable ""","""ϐ"""
"""""",""": Lagrangian=""",""": OWA="""
"""""","""Minimum found.""","""ꂽŏB"""
"""""","""Objective function value is NaN!""","""ړI֐lNaNł!"""
"""""","""Free variable ""","""Rύ"""
"""""",""" from bound """,""" oEh"""
"""""","""dg'*dx negative!""","""'dg'*dxےI!"""
"""""","""L*direct[""","""L*͎w܂B"""
"""""","""] is NaN!""","""] NaN͂ł?!"""
"""""","""|diag=""",""""""
"""""","""direct is NaN!""","""_CNgł̂́ANaNł!"""
"""""","""Cannot find minimum""","""ŏ邱Ƃł܂B"""
"""""",""" -- too many interations!""",""" -- ܂ɑinterations!"""
"""""","""] NaN! P=""",""""""
"""""",""",sigma=""","""VO}="""
"""""",""",sclar=""","""sclar="""
"""""","""sigma NaN/Inf! rho=""","""VO}NaN/Inf!rho="""
"""""",""",theta=""","""theta="""
"""""",""",oldsigma=""","""oldsigma="""
"""""","""Uses extended mode.""","""pr̓[hL܂B"""
"""""","""ProtectedProperties cannot be modified!""","""ProtectedPropertiesύX邱Ƃł܂!"""
"""""","""Queue is empty""","""҂s͋łB"""
"""""","""Queue Contents ""","""҂sRec"""
"""""",""" elements\n""",""" vf\n"""
"""""","""Empty\n""","""\n"""
"""""","""After pushing command line arguments""","""R}hCc_"""
"""""","""Pop: ""","""|bvX: """
"""""","""ERROR: pop did not throw exception!""",""": |bvX͗O𓊂܂ł!"""
"""""","""Pop on empty queue correctly gave exception.""","""̑҂sɊւ|bvX͐O^܂B"""
"""""","""Shape parameter of Erlang distribution must be greater than 1!""","""ErlangzɊւ`p[^1ȏłɈႢ܂!"""
"""""","""Shape parameter of Gamma distribution""","""GammazɊւ`p[^"""
"""""","""must be greater than 0!""","""0ȏ͂łɈႢ܂?!"""
"""""","""Generate ""","""܂B"""
"""""",""" values with std. exp dist:""",""" std. exp distl:"""
"""""",""" std. Erlang-5 dist:""",""" stdB A[-5dist:"""
"""""",""" std. Gamma(4.5) dist:""",""" stdB K}(4.5)dist:"""
"""""",""" std. Gamma(0.5) dist:""",""" stdB K}(0.5)dist:"""
"""""","""\n\nGenerate ""","""\n\nGenerate"""
"""""",""" values with""",""" l"""
"""""",""" std. Gaussian(5, 2) dist:""",""" stdB KEX(5A2)dist:"""
"""""","""\nMean is ""","""\nMean͂łB"""
"""""",""", Variance is """,""", ῶłB"""
"""""","""Empty""","""ɂȂĂB"""
"""""","""Strings: ""","""XgO: """
"""""","""Invert: ""","""tɂ܂: """
"""""","""Cols: """,""": """
"""""","""No upper limit has been specified for range""","""͑S͈͂Ɏw肳Ă܂B"""
"""""","""Invalid range list at ""","""͈͂Lڂal"""
"""""","""Usage: Range <rangespec>""","""p@: ͈<rangespec>"""
"""""",""": VERBOSE ON""",""": 璷"""
"""""","""Class ""","""NX"""
"""""",""" not found!""",""" ݗ܂!"""
"""""","""superclass""","""uX[p[-NXv"""
"""""","""otherclass""",""""""
"""""","""Trying to create URL from '""","""'URL쐬gC'"""
"""""","""' generates this exception:\n""","""'̗O: \n𔭐܂'"""
"""""","""Classpath ""","""Classpath"""
"""""",""", package """,""", pbP[W"""
"""""","""- Checking: ""","""- ƍ: """
"""""","""- Added: ""","""- : """
"""""","""Usage: java ""","""p@: java"""
"""""",""" [<package>] <subclass>""",""" <pbP[W܂><TuNX>"""
"""""","""equal to""",""""""
"""""","""Selected tag is not valid""","""Iꂽ^O͗Lł͂܂B"""
"""""","""Upper limit has not been specified""","""͎w肳Ă܂B"""
"""""","""No upper limit has been specified for index""","""͑SCfbNXɎw肳Ă܂B"""
"""""","""No index set""","""CfbNXZbg܂B"""
"""""","""Index must be greater than zero""","""CfbNX̓[ȏłɈႢ܂B"""
"""""","""Index is too large""","""CfbNX͑傫߂܂B"""
"""""","""Usage: SingleIndex <indexspec>""","""p@: SingleIndex<indexspec>"""
"""""","""Input: """,""": """
"""""","""Instance doesn't have access to a dataset!""","""CX^X̓f[^Zbgɋ߂ÂiĂ܂!"""
"""""","""Unequal number of attributes!""","""sȐ̑!"""
"""""",""" Val:""",""" @:"""
"""""","""This should never happen!""","""͌ċNׂł͂܂!"""
"""""","""length""",""""""
"""""","""weight""","""d"""
"""""","""race""","""[X"""
"""""","""The instance: ""","""CX^X: """
"""""","""First attribute: ""","""ŏ̑: """
"""""","""Class index: ""","""NX͍܂: """
"""""","""Class is missing: ""","""NX͌Ă܂: """
"""""","""Class value (internal format): ""","""Kl(̌`): """
"""""","""Shallow copy: ""","""󂢃Rs[: """
"""""","""Shallow copy with dataset set: ""","""f[^Zbg󂢃Rs[̓Zbg܂: """
"""""","""All stored values in internal format: ""","""ׂĂ̌`Œlۑ܂: """
"""""","""All values set to zero: ""","""ׂĂ̒l[ɃZbg܂: """
"""""","""All values set to one: ""","""ׂĂ̒l1ɃZbg܂: """
"""""","""Copy with first attribute deleted and inserted: ""","""ŏ̑폜āA}ĂԂŁARs[Ă: """
"""""","""Copy with second attribute deleted and inserted: ""","""2Ԗڂ̑폜āA}ĂԂŁARs[Ă: """
"""""","""Copy with third attribute deleted and inserted: ""","""3Ԗڂ̑폜āA}ĂԂŁARs[Ă: """
"""""","""Enumerating attributes (leaving out class):""","""(NXȂ)񋓂܂:"""
"""""","""Header of original and copy equivalent: ""","""IWiƃRs[̃wb_[: """
"""""","""Weight of copy missing: ""","""Rs[̎蓦Ƃ̏d: """
"""""","""Length of copy missing: ""","""Rs[̎蓦Ƃ̒: """
"""""","""Missing value coded as: ""","""ȉƂăR[hꂽl """
"""""","""Number of attributes: ""","""̐: """
"""""","""Number of classes: ""","""NX̐: """
"""""","""Copy with missing value replaced: ""","""lւĂăRs[Ă: """
"""""","""Copy with missing class: ""","""ĂNXƋɃRs[Ă: """
"""""","""Copy with class value set to first value: ""","""KlRs[͍ŏɁAlɃZbg܂: """
"""""","""Copy with class value set to ""third"": ""","""KlRs[́uu3ԖځvvɃZbg܂: """
"""""","""Copy with second attribute set to be missing: ""","""2Ԗڂ̑Rs[͌悤ɃZbg܂: """
"""""","""Copy with length set to be missing: ""","""Rs[͌悤ɃZbg܂: """
"""""","""Copy with first attribute set to 0: ""","""ŏ̑Rs[0ɃZbg܂: """
"""""","""Copy with weight attribute set to 1: ""","""d̑Rs[1ɃZbg܂: """
"""""","""Copy with position set to ""second"": ""","""ʒuRs[́uu2ԖڂɁvvɃZbg܂: """
"""""","""Copy with last attribute set to ""first"": ""","""Ō̑Rs[́uuŏɁvvɃZbg܂: """
"""""","""Current weight of instance copy: ""","""CX^XRs[݂̌̏d: """
"""""","""Current weight of instance copy (set to 2): ""","""CX^XRs[(2ɐݒ肷)݂̌̏d: """
"""""","""Last value of copy: ""","""Rs[̍ŏIl: """
"""""","""Value of position for copy: ""","""Rs[̂߂̈ʒu̒l: """
"""""","""Last value of copy (internal format): ""","""Rs[(̌`)̍ŏIl: """
"""""","""Value of position for copy (internal format): ""","""Rs[(̌`)̂߂̈ʒu̒l: """
"""""","""Can't compute binomial coefficient.""","""2WvZ邱Ƃł܂B"""
"""""","""Can't compute multinomial coefficient.""","""̌WvZ邱Ƃł܂B"""
"""""","""Binomial 6 over 2: ""","""񍀎6A2ȏ: """
"""""","""Multinomial 6 over 1, 2, 3: ""","""A6 1ȏA2A3: """
"""""","""as is""","""̂܂"""
"""""","""lnGamma: Overflow""","""lnGamma: I[o[t["""
"""""","""gamma: overflow""","""K}: I[o[t["""
"""""","""gamma: singular""","""K}: ܂"""
"""""","""ibeta: Domain error!""","""ibeta: hC!"""
"""""","""Binomial standard error (0.5, 100): ""","""񍀎̕W덷(0.5A100): """
"""""","""Chi-squared probability (2.558, 10): ""","""L[œ悳ꂽm(2.558A10): """
"""""","""Normal probability (0.2): ""","""W̊m(0.2): """
"""""","""F probability (5.1922, 4, 5): ""","""Fm(5.1922A4A5): """
"""""","""lnGamma(6): """,""""""
"""""","""able""","""ł"""
"""""","""about""",""""""
"""""","""above""",""""""
"""""","""according""","""v܂B"""
"""""","""accordingly""","""ɏ]"""
"""""","""across""","""a"""
"""""","""actually""","""ۂ"""
"""""","""after""",""""""
"""""","""afterwards""","""̌"""
"""""","""again""","""Ă"""
"""""","""against""",""""""
"""""","""all""","""ׂ"""
"""""","""allow""","""e܂B"""
"""""","""allows""","""e܂B"""
"""""","""almost""","""قƂ"""
"""""","""alone""","""P"""
"""""","""along""",""""""
"""""","""already""",""""""
"""""","""also""","""܂"""
"""""","""although""",""""""
"""""","""always""",""""""
"""""","""among""",""""""
"""""","""amongst""",""""""
"""""","""and""",""""""
"""""","""another""",""""""
"""""","""any""","""炩"""
"""""","""anybody""",""""""
"""""","""anyhow""","""Ƃɂ"""
"""""","""anyone""",""""""
"""""","""anything""","""ł"""
"""""","""anyway""","""Ƃɂ"""
"""""","""anyways""",""""""
"""""","""anywhere""","""ǂł"""
"""""","""apart""",""""""
"""""","""appear""","""܂B"""
"""""","""appreciate""","""ӂĂB"""
"""""","""appropriate""","""K"""
"""""","""are""","""܂B"""
"""""","""around""",""""""
"""""","""aside""","""T"""
"""""","""ask""","""q˂ĂB"""
"""""","""asking""","""q˂܂B"""
"""""","""associated""","""ۂ܂B"""
"""""","""available""","""p\"""
"""""","""away""","""Ă"""
"""""","""awfully""","""ƂĂ"""
"""""","""became""","""Ȃ܂B"""
"""""","""because""",""""""
"""""","""become""","""ȂĂB"""
"""""","""becomes""","""Ȃ܂B"""
"""""","""becoming""","""Ȃ邱"""
"""""","""been""","""܂B"""
"""""","""before""","""ȑO"""
"""""","""beforehand""","""炩"""
"""""","""behind""","""w"""
"""""","""being""",""""""
"""""","""believe""","""MĂB"""
"""""","""below""","""ȉ"""
"""""","""beside""",""""""
"""""","""besides""",""""""
"""""","""best""","""őP"""
"""""","""better""","""ǂ"""
"""""","""between""",""""""
"""""","""beyond""",""""""
"""""","""both""",""""""
"""""","""brief""","""v"""
"""""","""but""",""""""
"""""","""came""","""܂B"""
"""""","""can""",""""""
"""""","""cannot""",""""""
"""""","""cant""","""t"""
"""""","""cause""",""""""
"""""","""causes""",""""""
"""""","""certain""","""m"""
"""""","""certainly""","""m"""
"""""","""changes""","""ω"""
"""""","""clearly""","""m"""
"""""","""com""",""""""
"""""","""come""","""ĂB"""
"""""","""comes""","""܂B"""
"""""","""concerning""","""֌W邱"""
"""""","""consequently""","""̌"""
"""""","""consider""","""lĂB"""
"""""","""considering""","""l܂B"""
"""""","""contain""","""܂ł܂B"""
"""""","""containing""","""ܗL"""
"""""","""contains""","""܂ł܂B"""
"""""","""corresponding""","""ΉĂ܂B"""
"""""","""could""",""""""
"""""","""course""","""R[X"""
"""""","""currently""",""""""
"""""","""definitely""","""m"""
"""""","""described""","""܂B"""
"""""","""despite""",""""""
"""""","""did""","""܂B"""
"""""","""different""","""قȂ"""
"""""","""does""","""܂B"""
"""""","""doing""",""""""
"""""","""done""","""܂B"""
"""""","""down""",""""""
"""""","""downwards""",""""""
"""""","""during""",""""""
"""""","""each""","""ꂼ"""
"""""","""edu""",""""""
"""""","""eight""","""8"""
"""""","""either""","""ǂ炩"""
"""""","""else""","""ق"""
"""""","""elsewhere""","""ق̏ꏊ"""
"""""","""enough""","""\"""
"""""","""entirely""","""S"""
"""""","""especially""",""""""
"""""","""etc""","""Ȃ"""
"""""","""even""","""ϓ"""
"""""","""ever""",""""""
"""""","""every""",""""""
"""""","""everybody""","""݂"""
"""""","""everyone""","""F"""
"""""","""everything""","""ׂ"""
"""""","""everywhere""","""鏊"""
"""""","""exactly""","""傤"""
"""""","""example""",""""""
"""""","""except""","""ĂB"""
"""""","""far""",""""""
"""""","""few""","""킸"""
"""""","""fifth""","""5Ԗ"""
"""""","""followed""","""Ă܂B"""
"""""","""following""","""̎"""
"""""","""follows""","""܂B"""
"""""","""for""",""""""
"""""","""former""","""O"""
"""""","""formerly""","""ȑO"""
"""""","""forth""",""""""
"""""","""from""",""""""
"""""","""further""","""w"""
"""""","""furthermore""","""̏"""
"""""","""gets""","""܂B"""
"""""","""getting""","""邱"""
"""""","""given""","""^܂B"""
"""""","""gives""","""^܂B"""
"""""","""goes""","""s܂B"""
"""""","""going""","""s܂B"""
"""""","""gone""","""s܂B"""
"""""","""got""","""܂B"""
"""""","""gotten""","""܂B"""
"""""","""greetings""","""A"""
"""""","""had""","""Ă܂B"""
"""""","""happens""","""N܂B"""
"""""","""hardly""","""قƂ"""
"""""","""has""","""Ă܂B"""
"""""","""have""","""Ă܂B"""
"""""","""having""","""L"""
"""""","""hello""","""ɂ"""
"""""","""hence""",""""""
"""""","""her""","""ޏ"""
"""""","""hereafter""",""""""
"""""","""hereby""","""ɂ"""
"""""","""herein""","""̏ꏊ"""
"""""","""hereupon""","""ɂ"""
"""""","""hers""","""ޏ̂"""
"""""","""herself""",""""""
"""""","""him""",""""""
"""""","""himself""",""""""
"""""","""his""","""ނ̂"""
"""""","""hither""",""""""
"""""","""hopefully""","""]"""
"""""","""how""","""ǂ̂悤"""
"""""","""howbeit""","""Ȃ"""
"""""","""however""","""Ȃ"""
"""""","""ignored""","""܂B"""
"""""","""immediate""",""""""
"""""","""inasmuch""",""""""
"""""","""inc""",""""""
"""""","""indeed""","""{"""
"""""","""indicate""","""܂B"""
"""""","""indicated""","""܂B"""
"""""","""indicates""","""܂B"""
"""""","""inner""",""""""
"""""","""insofar""","""̒xɂ"""
"""""","""instead""",""""""
"""""","""into""",""""""
"""""","""inward""",""""""
"""""","""its""",""""""
"""""","""itself""","""ꎩ"""
"""""","""just""","""܂"""
"""""","""keep""","""ۂĂB"""
"""""","""keeps""","""ۂ܂B"""
"""""","""kept""","""ۂ܂B"""
"""""","""know""","""mĂB"""
"""""","""knows""","""mĂ܂B"""
"""""","""known""","""mĂ܂B"""
"""""","""lately""","""ŋ"""
"""""","""later""","""x"""
"""""","""latter""",""""""
"""""","""latterly""","""߂"""
"""""","""least""","""ŏ"""
"""""","""less""","""ȉ"""
"""""","""lest""",""""""
"""""","""let""","""݂܂B"""
"""""","""like""",""""""
"""""","""liked""","""D܂B"""
"""""","""likely""","""肻"""
"""""","""little""",""""""
"""""","""look""","""O"""
"""""","""looking""","""܂B"""
"""""","""looks""","""ʑ"""
"""""","""ltd""",""""""
"""""","""mainly""",""""""
"""""","""many""",""""""
"""""","""may""",""""""
"""""","""maybe""","""Ȃ"""
"""""","""mean""",""""""
"""""","""meanwhile""",""""""
"""""","""merely""","""P"""
"""""","""might""",""""""
"""""","""more""",""""""
"""""","""moreover""","""܂"""
"""""","""most""",""""""
"""""","""mostly""","""قƂ"""
"""""","""much""",""""""
"""""","""must""","""K{"""
"""""","""myself""",""""""
"""""","""namely""","""Ȃ킿"""
"""""","""near""","""߂"""
"""""","""nearly""","""قƂ"""
"""""","""necessary""","""Kv"""
"""""","""need""","""Kv"""
"""""","""needs""","""Kv"""
"""""","""neither""","""ǂ"""
"""""","""never""",""""""
"""""","""nevertheless""","""ɂ炸"""
"""""","""new""","""V"""
"""""","""next""",""""""
"""""","""nine""","""9"""
"""""","""nobody""","""l"""
"""""","""non""",""""""
"""""","""none""","""Ȃ"""
"""""","""noone""",""""""
"""""","""nor""","""܂"""
"""""","""normally""","""ʏ"""
"""""","""not""",""""""
"""""","""nothing""","""łȂ"""
"""""","""novel""",""""""
"""""","""now""",""""""
"""""","""nowhere""","""ǂɂ"""
"""""","""obviously""","""炩"""
"""""","""often""","""΂"""
"""""","""okay""","""F"""
"""""","""old""","""Â"""
"""""","""once""","""x"""
"""""","""ones""",""""""
"""""","""only""","""B"""
"""""","""onto""",""""""
"""""","""other""",""""""
"""""","""others""","""̂"""
"""""","""otherwise""","""ł͂܂"""
"""""","""ought""",""""""
"""""","""our""",""""""
"""""","""ours""","""̂"""
"""""","""ourselves""","""B"""
"""""","""outside""","""O"""
"""""","""over""","""I"""
"""""","""overall""","""I"""
"""""","""own""",""""""
"""""","""particular""",""""""
"""""","""particularly""",""""""
"""""","""per""",""""""
"""""","""perhaps""","""炭"""
"""""","""placed""","""܂܂B"""
"""""","""please""","""肢܂"""
"""""","""plus""","""vX"""
"""""","""possible""","""\"""
"""""","""presumably""","""炭"""
"""""","""probably""","""Ԃ"""
"""""","""provides""","""񋟂܂B"""
"""""","""que""",""""""
"""""","""quite""","""S"""
"""""","""rather""","""ނ"""
"""""","""really""","""{"""
"""""","""reasonably""","""I"""
"""""","""regarding""","""֌W"""
"""""","""regardless""","""s"""
"""""","""regards""",""""""
"""""","""relatively""","""rI"""
"""""","""respectively""","""ꂼ"""
"""""","""right""",""""""
"""""","""said""","""Ă܂B"""
"""""","""same""",""""""
"""""","""saw""","""܂B"""
"""""","""say""","""ĂB"""
"""""","""saying""","""Ƃ킴"""
"""""","""says""","""܂B"""
"""""","""second""","""2Ԗ"""
"""""","""secondly""",""""""
"""""","""see""","""ĂB"""
"""""","""seeing""","""܂B"""
"""""","""seem""","""܂B"""
"""""","""seemed""","""܂B"""
"""""","""seeming""","""܂B"""
"""""","""seems""","""܂B"""
"""""","""seen""","""܂B"""
"""""","""self""",""""""
"""""","""selves""",""""""
"""""","""sensible""","""ʂ"""
"""""","""sent""","""M܂B"""
"""""","""serious""","""d"""
"""""","""seriously""","""^"""
"""""","""seven""","""7"""
"""""","""several""",""""""
"""""","""shall""",""""""
"""""","""she""","""ޏ"""
"""""","""should""",""""""
"""""","""since""","""ȗ"""
"""""","""six""","""6"""
"""""","""some""",""""""
"""""","""somebody""","""ꂩ"""
"""""","""somehow""","""ǂɂ"""
"""""","""someone""","""ꂩ"""
"""""","""something""",""""""
"""""","""sometime""",""""""
"""""","""sometimes""","""X"""
"""""","""somewhat""","""炩"""
"""""","""somewhere""","""ǂ"""
"""""","""soon""",""""""
"""""","""sorry""","""݂܂"""
"""""","""specified""","""w肳܂B"""
"""""","""specify""","""w肵ĂB"""
"""""","""specifying""","""w肵܂B"""
"""""","""still""","""܂"""
"""""","""sub""",""""""
"""""","""such""","""̂悤Ȃ"""
"""""","""sup""",""""""
"""""","""sure""","""m"""
"""""","""take""","""Be"""
"""""","""taken""","""܂B"""
"""""","""tell""","""ĂB"""
"""""","""tends""","""X܂B"""
"""""","""than""",""""""
"""""","""thank""","""ӂĂB"""
"""""","""thanks""",""""""
"""""","""thanx""",""""""
"""""","""that""",""""""
"""""","""thats""",""""""
"""""","""the""",""""""
"""""","""their""",""""""
"""""","""theirs""","""ޓ̂"""
"""""","""them""",""""""
"""""","""themselves""",""""""
"""""","""then""","""̎"""
"""""","""thence""",""""""
"""""","""there""","""ł"""
"""""","""thereafter""","""̌"""
"""""","""thereby""","""̌"""
"""""","""therefore""",""""""
"""""","""therein""",""""""
"""""","""theres""",""""""
"""""","""thereupon""",""""""
"""""","""these""",""""""
"""""","""they""",""""""
"""""","""think""","""vĂB"""
"""""","""third""","""3Ԗ"""
"""""","""this""",""""""
"""""","""thorough""","""OI"""
"""""","""thoroughly""","""OI"""
"""""","""those""",""""""
"""""","""though""","""Ƃ"""
"""""","""through""","""˂"""
"""""","""throughout""","""_"""
"""""","""thru""","""OI"""
"""""","""thus""","""̂悤ɂ"""
"""""","""together""","""ꏏɂ"""
"""""","""too""","""܂"""
"""""","""took""","""܂B"""
"""""","""toward""","""Ă"""
"""""","""towards""",""""""
"""""","""tried""","""݂܂B"""
"""""","""tries""","""gC"""
"""""","""truly""","""{"""
"""""","""try""","""݂ĂB"""
"""""","""trying""","""݂܂B"""
"""""","""twice""","""x"""
"""""","""under""",""""""
"""""","""unfortunately""","""cOȂ"""
"""""","""unless""",""""""
"""""","""unlikely""","""肻Ȃ"""
"""""","""until""",""""""
"""""","""unto""",""""""
"""""","""upon""",""""""
"""""","""use""","""gp"""
"""""","""used""","""gp܂B"""
"""""","""useful""","""ɗ"""
"""""","""uses""","""pr"""
"""""","""using""","""gp"""
"""""","""usually""","""ʏ"""
"""""","""uucp""",""""""
"""""","""various""","""lX"""
"""""","""very""","""܂"""
"""""","""via""",""""""
"""""","""viz""","""܂"""
"""""","""want""","""~łB"""
"""""","""wants""","""Ki"""
"""""","""was""","""܂B"""
"""""","""way""",""""""
"""""","""welcome""","""}"""
"""""","""well""",""""""
"""""","""went""","""s܂B"""
"""""","""were""","""܂B"""
"""""","""what""",""""""
"""""","""whatever""","""ł"""
"""""","""when""",""""""
"""""","""whence""","""N"""
"""""","""whenever""",""""""
"""""","""where""","""ǂ"""
"""""","""whereafter""",""""""
"""""","""whereas""","""Ƃ낪"""
"""""","""whereby""","""ǂ"""
"""""","""wherein""","""ǂ̓_"""
"""""","""whereupon""",""""""
"""""","""wherever""","""ǂ"""
"""""","""whether""",""""""
"""""","""which""","""ǂ"""
"""""","""while""",""""""
"""""","""whither""","""ړIn"""
"""""","""who""",""""""
"""""","""whoever""","""Nł"""
"""""","""whole""","""S"""
"""""","""whom""",""""""
"""""","""whose""","""̂"""
"""""","""why""","""Ȃ"""
"""""","""will""","""ӎu"""
"""""","""willing""","""]"""
"""""","""wish""","""]"""
"""""","""with""",""""""
"""""","""within""",""""""
"""""","""without""",""""""
"""""","""wonder""",""""""
"""""","""would""",""""""
"""""","""yet""","""܂"""
"""""","""you""","""Ȃ"""
"""""","""your""","""Ȃ"""
"""""","""yours""","""Ȃ̂"""
"""""","""yourself""",""""""
"""""","""yourselves""",""""""
"""""","""zero""","""["""
"""""","""Problem reading default properties: ""","""̉{ǃftHg̓: """
"""""","""Warning, unable to load properties file from ""","""xĂāÃt@C[h邱Ƃł܂B"""
"""""","""system resource (Utils.java)""","""VXe(Utils.java)"""
"""""","""Problem reading user properties: ""","""̉{ǃ[U̓: """
"""""","""Problem reading local properties: ""","""̓Ǐ̃[J̓: """
"""""","""Object""","""IuWFNg"""
"""""","""Illegal options: ""","""s@ȃIvV: """
"""""","""-Char""","""-Y"""
"""""","""-String""","""-XgO"""
"""""","""No value given for -""","""R̂Ƃ]A-"""
"""""",""" option.""",""" IvVB"""
"""""","""String should not finish with \\""","""XgO\\ŏIׂł͂܂B"""
"""""","""Unknow character \\""","""UnknowLN^\\"""
"""""","""Quote parse error.""","""𕪐͂悤ɈpĂB"""
"""""",""" is not assignable from """,""" u蓖-\vłȂ"""
"""""","""Can't normalize array. Sum is NaN.""","""z𐳏ɂ邱Ƃł܂B vNaNłB"""
"""""","""Can't normalize array. Sum is zero.""","""AC𐳏ɂ邱Ƃł܂B v̓[łB"""
"""""","""Introduction to Algorithms""","""ASYւ̏_"""
"""""","""First option split up:""","""1̑I͕􂵂܂:"""
"""""","""Partitioned options: ""","""d؂ꂽIvV: """
"""""","""Get flag -f: ""","""-fɓĂ: """
"""""","""Get option -o: ""","""IvV-oɓĂ: """
"""""","""Checking for remaining options... ""","""IvV̂܂܂ŎcĂ̂Ȃǂ`FbN܂c"""
"""""","""Original array with NaN (doubles): ""","""NaN({)IWi̔z: """
"""""","""Original array (doubles): ""","""IWi̔z({܂): """
"""""","""Original array (ints): ""","""IWi̔z(ints): """
"""""","""Correlation: ""","""֊֌W: """
"""""","""Mean: """,""": """
"""""","""Variance: ""","""ω: """
"""""","""Sum (doubles): ""","""v({܂): """
"""""","""Sum (ints): ""","""v(ints): """
"""""","""Max index (doubles): ""","""}bNXCfbNX({܂): """
"""""","""Max index (ints): ""","""}bNXCfbNX(ints): """
"""""","""Min index (doubles): ""","""͍܂({܂): """
"""""","""Min index (ints): ""","""͍܂(ints): """
"""""","""Median (doubles): ""","""fBA({܂): """
"""""","""Median (ints): ""","""fBA(ints): """
"""""","""Sorted array with NaN (doubles): ""","""NaN({)镪ނꂽz: """
"""""","""Sorted array (doubles): ""","""ނꂽz({܂): """
"""""","""Sorted array (ints): ""","""ނꂽz(ints): """
"""""","""Indices from stable sort (doubles): ""","""܂₩̃CfbNXXg͕ނ܂({܂): """
"""""","""Indices from sort (ints): ""","""(ints)̃CfbNXXg: """
"""""","""Normalized array (doubles): ""","""ɂꂽz({܂): """
"""""","""Normalized again (doubles): ""","""Ă({)ɂ܂: """
"""""","""-4.58: """,""""""
"""""","""-6.78: """,""""""
"""""","""5.70001 == 5.7 ? """,""""""
"""""","""5.70001 > 5.7 ? """,""""""
"""""","""5.70001 >= 5.7 ? """,""""""
"""""","""5.7 < 5.70001 ? """,""""""
"""""","""5.7 <= 5.70001 ? """,""""""
"""""","""Info (ints): ""","""CtH[V(ints): """
"""""","""log2(4.6): """,""""""
"""""","""5 * log(5): ""","""5 *O(5): """
"""""","""5.5 rounded: ""","""5.5 ۂ: """
"""""","""5.55555 rounded to 2 decimal places: ""","""5.55555͏2ʂɈ܂: """
"""""","""Array-Dimensions of 'new int[][]': ""","""'Vint̃ACdvA'A: """
"""""","""Array-Dimensions of 'new int[][]{{1,2,3},{4,5,6}}': ""","""'Vint̃ACdvA{{1A2A3}A{4A5A6}A'A: """
"""""","""Array-Dimensions of 'new String[3][4][]': ""","""'VXgO3 4̃ACdvA'A: """
"""""","""weka.core.Version: Unable to load version information!""","""weka.core.Version: o[W[h邱Ƃł܂!"""
"""""",""": no version-string for comparTo povided!""",""": comparTo povided̂߂̃o[WXgO܂!"""
"""""","""\ncomparing with ""","""\Ancomparing܂B"""
"""""","""isOlder? ""","""isOlder?"""
"""""","""equals ? ""","""y? """
"""""","""isNewer? ""","""isNewer?"""
"""""","""readObject""",""""""
"""""","""addObject""",""""""
"""""","""close""",""""""
"""""","""KOML is not present!""","""KOML݂͑Ă܂!"""
"""""","""Failed to deserialize object from binary file '""","""'oCi[t@CIuWFNg𔽘Aڂ邽߂ɁAs܂'"""
"""""","""Failed to deserialize object from XML file '""","""'XMLt@CIuWFNg𔽘Aڂ邽߂ɁAs܂'"""
"""""",""" uid='oldUID'""",""""""
"""""",""" uid='newUID'""",""""""
"""""",""" uid='""",""" 'uid='"""
"""""","""Usage: ""","""p@: """
"""""",""" <oldUID> <newUID> <oldFilename> <newFilename>""",""" <oldUID><oldFilename<newUID>><newFilename>"""
"""""","""       <oldFilename> and <newFilename> have to be different""",""" <oldFilename><newFilename>͈قȂĂȂ΂Ȃ܂B"""
"""""","""Filenames have to be different!""","""t@C͈قȂĂȂ΂Ȃ܂!"""
"""""","""mapping""","""}bsO"""
"""""","""key""","""L["""
"""""","""cells""","""Z"""
"""""","""DefaultListModel""",""""""
"""""","""Map""","""n}"""
"""""","""Collection""","""W"""
"""""","""Matrix""","""}gNX"""
"""""","""MatrixOld""",""""""
"""""","""CostMatrixOld""",""""""
"""""","""' is not a recognized name for maps!""","""'FꂽO͒n}̂߂̂̂ł͂܂?!'"""
"""""","""&lt;?xml version=""1.0"" encoding=""utf-8""?&gt;""","""ultv uutf-8C`?v (xmlo[W=v u1C`ṽR[h=gt)"""
"""""","""<?xml version=""1.0"" encoding=""utf-8""?>""","""uv <?xmlo[W=u1C`vR[h=v́uutf-8C`v>?"""
"""""","""option""","""IvV"""
"""""","""type""","""^Cv"""
"""""","""flag""",""""""
"""""","""single""","""VO"""
"""""","""hyphens""","""nCt"""
"""""",""" CDATA ""classifier"">\n""",""" CDATA ""ފwKASY"">\n"""
"""""",""" CDATA """">\n""",""""""
"""""",""" CDATA #REQUIRED>\n""",""""""
"""""",""" (flag | single | hyphens | quotes) ""single"">\n""",""" (|P̏ԂŊgĂ| nCt| p) uuVOvv>\n"""
"""""","""quotes""","""p"""
"""""","""\nString array:\n""","""\n̔z: \n"""
"""""","""Smith""","""X~X"""
"""""","""version""","""o[W"""
"""""","""array""","""z"""
"""""","""__root__""","""____"""
"""""","""<!DOCTYPE """,""""""
"""""","""   <!ELEMENT """,""""""
"""""",""" (#PCDATA | """,""""""
"""""","""      CDATA #REQUIRED>\n""",""""""
"""""","""     CDATA #REQUIRED>\n""",""""""
"""""",""" CDATA """"",""""""
"""""","""     CDATA """"",""""""
"""""",""""">   <!-- the dimensions of the array; no=0, yes=1 -->\n""","""""> <!--AC̎; =͂A0A=1-->\n"""
"""""","""      CDATA """"",""""""
"""""","""   <!ATTLIST """,""""""
"""""","""   CDATA """"",""""""
"""""","""trace: ""","""g[X: """
"""""","""WARNING: has no version!""","""x: o[WSĂ܂!"""
"""""","""WARNING: loading a newer version (""","""x: Vo[W[hA("""
"""""","""NOTE: loading an older version (""",""": ̃o[W[hA("""
"""""","""get""","""ĂB"""
"""""","""set""","""Zbg܂B"""
"""""","""yes""","""͂"""
"""""","""PROBLEM (write): ""","""(܂): """
"""""","""object""","""IuWFNg"""
"""""","""primitive""","""n"""
"""""","""pseudo""","""^"""
"""""","""Cannot get primitive for class '""","""'NXɌnIɂȂ邱Ƃł܂'"""
"""""","""WARNING: unknown property '""","""x: 'm̓'"""
"""""","""ERROR: Can't instantiate '""",""": 'Ꭶ邱Ƃł܂'"""
"""""","""Happened near: ""","""߂ԂŁAN܂: """
"""""","""PROBLEM (read): ""","""(ǂ݂܂): """
"""""","""Expected '""","""'\z܂'B"""
"""""","""' as root element, but found '""","""'vfÂ܂A̂'"""
"""""","""<?xml""",""""""
"""""","""read|write""","""ǂłB|ĂB"""
"""""","""readFromXML""",""""""
"""""","""writeToXML""",""""""
"""""","""read""","""ǂłB"""
"""""","""write""","""ĂB"""
"""""","""Read Methods:\n""","""@: \nǂłB"""
"""""","""Write Methods:\n""","""@: \nĂB"""
"""""","""Current system has only ""","""݂̃VXe͂łB"""
"""""",""" dimensions.""",""" @B"""
"""""","""A data generator that produces data points in ""","""ꂪf[^|Cg𐶎Yf[^[l[^"""
"""""","""clusters.""","""NX^B"""
"""""","""\tSet pattern to grid (default is random).""","""\tSet̓ObhɌ^ɊÂč܂(ftHgׂ͖ł)B"""
"""""","""\tSet pattern to sine (default is random).""","""\tSet͐܂Ō^ɊÂč܂(ftHgׂ͖ł)B"""
"""""","""\tThe range of number of instances per cluster (default 1..50).""","""NX^(ftHg1.50)̃CX^X̐\tThé͈B"""
"""""","""-N <num>..<num>""","""-N<num>B<num>"""
"""""","""\tThe range of radius per cluster (default 0.1..sqrt(2)).""","""\tThe1NX^̔ay΂܂B(ftHg0.1..sqrt(2))B"""
"""""","""-R <num>..<num>""","""-R<num>B<num>"""
"""""","""\tThe distance multiplier (default 4).""","""\tThe͏搔(ftHg4)܂B"""
"""""","""\tThe number of cycles (default 4).""","""\tTheJԂ(ftHg4)B"""
"""""","""\tSet input order to ordered (default is randomized).""","""\tSet̓I[_[𖽗߂̂ɓ͂܂(ftHg̓_}CY܂)B"""
"""""","""\tThe noise rate in percent (default 0).""","""p[Zg(ftHg0)ŕ\\tTheGB"""
"""""","""\tThe Seed for random function (default 1).""","""m֐(ftHg1)̂߂\tThe SeedB"""
"""""","""Flags G and I can only be set mutually exclusiv.""","""GƎ݂͌exclusivݒ肷邱ƂłɂȂ܂B"""
"""""","""Option M can only be used with GRID pattern.""","""GRIDp^[ƋɃIvVMgp邱Ƃł邾łB"""
"""""","""Option C can only be used with SINE pattern.""","""SINEp^[ƋɃIvVCgp邱Ƃł邾łB"""
"""""","""RANDOMIZED is not yet implemented.""","""RANDOMIZED͂܂sĂ܂B"""
"""""","""GridSize= ""","""GridSize="""
"""""","""GridWidth= ""","""GridWidth="""
"""""","""\n%\n%\n""",""""""
"""""","""% Cluster: c""","""%͌Q܂: c"""
"""""","""% StandardDeviation: ""","""%StandardDeviation: """
"""""","""% Number of instances: ""","""%Number̗: """
"""""","""% Total number of instances: ""","""TotaltԂ%: """
"""""",""" clusters\n""",""" \nQ܂B"""
"""""","""% Pattern chosen           : ""","""I΂ꂽ%Pattern: """
"""""","""GRID, ""","""iq"""
"""""","""distance multiplier = ""","""搔="""
"""""","""SINE\n""","""\n"""
"""""","""RANDOM\n""","""ׂ\n"""
"""""","""-r <relation name>\n""","""-r<֌W>\n"""
"""""","""\tThe name of the relation for the produced dataset.\n""","""\tThe͊֌WɂĐYɂȂŃf[^Zbg\nƖ܂B"""
"""""","""\tThe number of attributes for the produced dataset.\n""","""Yꂽf[^Zbĝ߂̑\tTheԍA\n"""
"""""","""-k <number of clusters>\n""","""-k<NX^̐>\n"""
"""""","""\tThe number of clusters the dataset is produced in.\n""","""\tTheԍANX^ł́Af[^ZbgYꂽC`łA\n"""
"""""","""\tThe class flag, if set, the cluster is listed in the class ""","""ݒ肳ȂA\tThẽNX͒oŁANX^̓NXŋLڂĂ܂B"""
"""""","""attribute.\n""","""\n"""
"""""","""\nData Generator options:\n\n""","""\nData GeneratorIvV: \n\n"""
"""""","""-a <number of attributes>\n""","""-a<̐>\n"""
"""""","""\tThe number of attributes the produced dataset should have.\n""","""Yꂽf[^Zbgׂł鑮\tTheԍɂ. \n܂B"""
"""""","""-c <number of classes>\n""","""-c<NX̐>\n"""
"""""","""\tThe number of classes the produced dataset should have.\n""","""Yꂽf[^ZbgׂłNX\tTheԍɂ. \n܂B"""
"""""","""-n <number of examples>\n""","""-n<̐>\n"""
"""""","""\tThe number of examples the produced dataset should have.\n""","""Yꂽf[^Zbgׂł\tTheԍɂ. \n܂B"""
"""""","""\tIf not supplied the instances will be written to stdout.\n""","""tIfȂ\stdout\n܂ŏł傤B"""
"""""","""A data generator that produces data randomly ""","""蓖肵Ƀf[^of[^[l[^"""
"""""","""with \'boolean\' (nominal with values {false,true}) and""","""\'_ZqA(l{ĂāA{}ł邱ƂŖڏ)\B"""
"""""","""numeric attributes by producing a decisionlist.""","""decisionlist𐶎Ŷɂ鐔lB"""
"""""","""\tmaximum size for rules (default 10) ""","""K̂߂\tmaximumTCY(ftHg10) """
"""""","""\tminimum size for rules (default 1) ""","""K̂߂\tminimumTCY(ftHg1) """
"""""","""\tnumber of irrelevant attributes (default 0)""","""֌W̑\tnumber(ftHg0)"""
"""""","""\tnumber of numeric attributes (default 0)""","""l\tnumber(ftHg0)"""
"""""","""\tseed for random function (default 1)""","""m֐̂߂tseedꂽ\(ftHg1)"""
"""""","""\tswitch on voting (default is no voting)""","""[ł\tswitch(ftHg͕[ł邱Ƃł͂܂)"""
"""""","""Possible rule size is below minimal rule size.""","""ŏʂ̋KTCY艺łɂ͉\ȋKTCY܂B"""
"""""","""Examples cannot be generated""","""͔邱Ƃł܂B"""
"""""",""" one by one.""",""" ЂƂB"""
"""""","""Dataset format not defined.""","""`Ȃf[^ZbgB"""
"""""","""Attribute type is not supported.""","""^Cv̓T|[g܂B"""
"""""","""Error in instance classification.""","""CX^XނɂB"""
"""""","""class""","""NX"""
"""""","""\n%\n% Number of attributes chosen as irrelevant = ""","""֌W=ƂđI΂ꂽ\n%\n%Numbeȓ"""
"""""","""%\n% DECISIONLIST (number of rules = ""","""%\n%DECISIONLISTA(K=̐"""
"""""","""% RULE ""","""%͓܂B"""
"""""","""not(""","""("""
"""""","""DD Conditional Estimator. ""","""DD̏ťςlB"""
"""""","""Discrete Estimator. Counts = ""","""UIȌςlB JEg="""
"""""","""  (Total = """,""" (v="""
"""""","""Val ""","""@"""
"""""",""" Weight:""",""" d:"""
"""""",""" EstProb(""",""" EstProbA("""
"""""","""DK Conditional Estimator. ""","""DK̏ťςlB"""
"""""","""DN Conditional Estimator. ""","""DN̏ťςlB"""
"""""","""Weights of each estimator given by ""","""^Ă邻ꂼ̌ςl̑̏d"""
"""""","""KD Conditional Estimator. ""","""KD̏ťςlB"""
"""""","""total: ""","""v: """
"""""",""" Normal Kernels. \nStandardDev = """,""" ȃJ[lB \nStandardDev="""
"""""","""  \nMean = 0""",""" nMean=0~"""
"""""","""\nWeights = ""","""\nWeights="""
"""""","""Data: ""","""f[^: """
"""""","""KK Conditional Estimator. ""","""KK̏ťςlB"""
"""""",""" Normal Kernels:\n""",""" ȃJ[l: \n"""
"""""","""StandardDev = ""","""StandardDev="""
"""""","""  \nMeans =""",""" \nMeans="""
"""""","""No covariance inverse\n""","""Ut\܂nB"""
"""""","""Mahalanovis Distribution. Mean = ""","""MahalanoviszB ="""
"""""","""  ConditionalOffset = """,""" ConditionalOffset="""
"""""","""Covariance Matrix: Determinant = ""","""U}gNX: I="""
"""""","""  Inverse:\n""",""" t: \n"""
"""""","""Covariance Matrix\n""","""U}gNX\n"""
"""""","""ND Conditional Estimator. ""","""m[X_R^̏ťςlB"""
"""""",""" sub-estimators:\n""",""" Tuςl: \n"""
"""""","""Sub-estimator ""","""TuςlłB"""
"""""","""NN Conditional Estimator. ""","""NN̏ťςlB"""
"""""",""" data points.  Mean = """,""" f[^͎w܂B ="""
"""""","""  Conditional mean = """,""" t̕="""
"""""","""  Covariance Matrix: \n""",""" U}gNX: \n"""
"""""","""## Conditional = ""","""## t="""
"""""","""Normal Distribution. Mean = ""","""KzB ="""
"""""",""" StandardDev = """,""" StandardDev="""
"""""",""" WeightSum = """,""" WeightSum="""
"""""",""" Precision = """,""" \="""
"""""","""Poisson Lambda = ""","""|A\Lambda="""
"""""","""Please specify a set of instances.""","""1Zbg̃CX^Xw肵ĂB"""
"""""","""Prediction for ""","""\"""
"""""","""Takes the results from a ResultProducer ""","""ResultProducer猋ʂ܂B"""
"""""","""and submits the average to the result listener. Normally used with ""","""āAʃXi[ɕςo܂B ʏAgpĂ܂B"""
"""""","""a CrossValidationResultProducer to perform n x m fold cross ""","""܂ڂ̌ĂԂn x msCrossValidationResultProducer"""
"""""","""validation.""","""@B"""
"""""","""Number of results collected: ""","""ʂ̐͏W܂܂: """
"""""","""Null numeric result field found:\n""","""ꂽklʃtB[h: \n"""
"""""","""Duplicate result received:""","""󂯎ꂽʂRs[Ă:"""
"""""","""Expected ""","""\z܂B"""
"""""",""" results matching key """"",""" L[ɍʁAuv"""
"""""",""""" but got ""","""uuvB"""
"""""","""First key:""","""ŏ̃L[:"""
"""""","""Last key :""","""Ō̃L[:"""
"""""","""Keys differ on fields other than """"","""L[tB[hňقȂAuv"""
"""""",""""" -- time to implement multiple averaging""","""uu{ւ̎Ԃ͕ς܂vB"""
"""""","""No key field called ""","""L[tB[h͑SĂт܂łB"""
"""""",""" produced by """,""" Y܂B"""
"""""","""\tThe name of the field to average over.\n""","""tThe. \n̏ŕς镪\"""
"""""","""\t(default ""Fold"")""","""\t(ftHguu܂ځvv)"""
"""""","""\tThe number of results expected per average.\n""","""1\nPʂŗ\zꂽʂ\tTheԍ"""
"""""","""-X <num results>""","""-X<num>"""
"""""","""\tCalculate standard deviations.\n""","""\tCalculateW΍\n"""
"""""","""\t(default only averages)""","""\t(ftHgAς)"""
"""""","""AveragingResultProducer: setting additional ""","""AveragingResultProducer: ݒAǉ"""
"""""","""Record standard deviations for each run.""","""eŝ߂ɕW΍L^ĂB"""
"""""","""Set the expected number of results to average per run. ""","""sPʂŕς錋ʂ̗\zꂽݒ肵ĂB"""
"""""","""For example if a CrossValidationResultProducer is being used ""","""Ⴆ΁ACrossValidationResultProducerłȂA݂͎gpĂ܂B"""
"""""","""(with the number of folds set to 10), then the expected number ""","""(10ɐݒ肳ꂽ܂ڂ̐), āA\zꂽ"""
"""""","""of results per run is 10.""","""1šʂɂāA10͂ł?"""
"""""","""Set the field name that will be unique for a run.""","""sɃj[NɂȂtB[hݒ肵ĂB"""
"""""","""Num_""","""k_"""
"""""","""Set the resultProducer for which results are to be averaged.""","""ς錋ʂƂłresultProducerݒ肵ĂB"""
"""""","""AveragingResultProducer: """,""""""
"""""",""" A SplitEvaluator that produces results for a classification """,""" ނ̂߂ɌSplitEvaluator"""
"""""","""scheme on a nominal class attribute.""","""ڏ̃NXŌv悵ĂB"""
"""""","""\tThe index of the class for which IR statistics\n""","""\tThe͂ǂIRv\nŃNXɍ邩B"""
"""""","""\tare to be output. (default 1)""","""o͂ł\JXmGhEB (ftHg1)"""
"""""","""\tThe index of an attribute to output in the\n""","""tThe\nŏo͂鑮\"""
"""""","""\tresults. This attribute should identify an\n""","""\tresultsB ̑\n肷ׂłB"""
"""""","""\tinstance in order to know which instances are\n""","""\tinstanceAǂ̗Ⴊ\nł邩mĂ܂B"""
"""""","""\tin the test set of a cross validation. if 0\n""","""eXgݒ肵Ă鍇@\XYA0~n"""
"""""","""\tno output (default 0).""","""tnoo͂\(ftHg0)B"""
"""""","""-I <index>""","""-<܂>"""
"""""","""\tAdd target and prediction columns to the result\n""","""\nւ\tAddڕWƗ\R"""
"""""","""\tfor each fold.""","""\tfor͂ꂼ܂dȂ܂B"""
"""""","""ClassifierSplitEvaluator: setting additional measures""","""ClassifierSplitEvaluator: ǉ[uݒ肵܂B"""
"""""","""Number_of_training_instances""","""_g[jO_̐_"""
"""""","""Number_of_testing_instances""","""_eXg_̐_"""
"""""","""Kappa_statistic""","""Jbp_vl"""
"""""","""True_positive_rate""","""^_z_[g"""
"""""","""Num_true_positives""","""k_̖{_"""
"""""","""False_positive_rate""","""_z_[g"""
"""""","""Num_false_positives""","""k_̌_"""
"""""","""True_negative_rate""","""^__[g"""
"""""","""Num_true_negatives""","""k_̖{_lK"""
"""""","""False_negative_rate""","""__[g"""
"""""","""Num_false_negatives""","""k_̋U_lK"""
"""""","""IR_precision""","""IR_x"""
"""""","""IR_recall""","""IR_R["""
"""""","""F_measure""","""F_͑肵܂B"""
"""""","""Instance_ID""","""_ID"""
"""""","""Targets""","""ڕW"""
"""""","""Predictions""","""\"""
"""""",""" SplitEvaluator that produces results for a classification scheme """,""" ތv̂߂ɌSplitEvaluator"""
"""""","""on a nominal class attribute, including weighted misclassification ""","""׏dĂ镪ތ܂ޖڏ̃NXɊւ"""
"""""","""costs.""","""RXgB"""
"""""","""\tName of a directory to search for cost files when loading\n""","""\n[hƂAfBNg\tName̓t@C܂B"""
"""""","""\tcosts on demand (default current directory).""","""If}h\tcosts(ftHgJgfBNg)B"""
"""""","""-D <directory>""","""-D<fBNg>"""
"""""","""The directory to look in for cost files. This directory will be ""","""pŒfBNg̓t@C܂B ̃fBNg͂ł傤B"""
"""""","""searched for cost files when loading on demand.""","""vɉă[hƂApt@C܂B"""
"""""","""Number_correct""","""_łB"""
"""""","""Number_incorrect""","""_smłB"""
"""""","""Number_unclassified""","""_͔񕪗ނ܂B"""
"""""","""Percent_correct""","""p[Zg_łB"""
"""""","""Percent_incorrect""","""p[Zg_smłB"""
"""""","""Percent_unclassified""","""p[Zg_͔񕪗ނ܂B"""
"""""","""Total_cost""","""v_p"""
"""""","""Average_cost""","""ς_p"""
"""""","""KB_information""","""KB_"""
"""""","""KB_mean_information""","""KB__Ӗ܂B"""
"""""","""KB_relative_information""","""KB_e_"""
"""""","""Class attribute is not nominal!""","""NX͖ڏł͂܂!"""
"""""","""On-demand cost file doesn't exist: ""","""v̔pt@C݂͑Ă܂: """
"""""","""CostSensitiveClassifierSplitEvaluator: """,""""""
"""""","""Fold""","""܂"""
"""""","""Performs a cross validation run using a supplied ""","""ꂽagp邱ƂŌĂ鍇@ss܂B"""
"""""","""CrossValidationResultProducer: setting additional ""","""CrossValidationResultProducer: ݒAǉ"""
"""""","""<null SplitEvaluator>""",""""""
"""""","""individual folds is saved. If the destination is a directory, ""","""X̐܂ڂ͐ߖ񂳂܂B ړInfBNgłȂ"""
"""""","""Number of folds to use in cross validation.""","""Ă鍇@Ɏgp܂ڂ̐B"""
"""""","""The evaluator to apply to the cross validation folds. ""","""Ă鍇@ɓKp]҂͐܂dȂ܂B"""
"""""","""\tThe number of folds to use for the cross-validation.\n""","""Ă鍇@. \ngp܂ڂ\tTheԍ"""
"""""","""-X <number of folds>""","""-X <܂ڂ̐>"""
"""""","""CrossValidationResultProducer: """,""""""
"""""","""comma separated value form.""","""R}ŋ؂ꂽl(CSV)`"""
"""""","""\tThe filename where output will be stored. Use - for stdout.\n""","""\to͂ۑt@CDWo͂ւ'-'gp\n"""
"""""","""\t(default temp file)""","""\t(ftHge|[t@C)"""
"""""","""-O <file name>""","""-O <t@C>"""
"""""","""File to save to. Use '-' to write to standard out.""","""ۑt@CD Wo͂ɏo͂ꍇ'-'gp"""
"""""","""Takes results from a result producer and sends them to a ""","""ʃvf[T[猋ʂ󂯎C"""
"""""","""database.""","""f[^x[Xɏo͂܂D"""
"""""","""Unrecognized ResultProducer calling postProcess!!""","""postProcessƌĂԔFĂȂResultProducer!"""
"""""","""Unrecognized ResultProducer calling acceptResult!!""","""acceptResultƌĂԔFĂȂResultProducer!"""
"""""","""Unrecognized ResultProducer calling isResultRequired!""","""isResultRequiredƌĂԔFĂȂResultProducer!"""
"""""","""Is result required...""","""Kvł錋ʂłc"""
"""""","""required""","""KvłB"""
"""""","""not required""","""Kvł͂܂B"""
"""""",""" (cache)""",""" (LbV܂)"""
"""""","""Set the name of the key field by which to cache.""","""L[tB[h̖Oݒ肵ĂAǂLbV邩B"""
"""""",""" (updating cache)""",""" (LbVAbvf[g܂)"""
"""""","""SELECT Key_""","""""",""""""
"""""","""No key field named ""","""w肳ȂL[tB[hS"""
"""""",""" (as specified for caching)""",""" (LbVɎw肳悤)"""
"""""","""Examines a database and extracts out ""","""OŃf[^x[Xƒo𒲂ׂ܂B"""
"""""","""the results produced by the specified ResultProducer ""","""w肳ꂽResultProducerɂĐ܂ꂽ"""
"""""","""and submits them to the specified ResultListener. If a result needs ""","""āAw肳ꂽResultListenerɂo܂B ʂ̕KvłB"""
"""""","""to be generated, the ResultProducer is used to obtain the result.""","""ȂAResultProduceŕAʂ𓾂̂Ɏgp܂B"""
"""""","""Got result from database: ""","""f[^x[X猋ʂ𓾂܂: """
"""""","""\tThe name of the database field to cache over.\n""","""\tLbVsf[^x[X̃tB[h\n"""
"""""","""\teg: ""Fold"" (default none)""","""\t: ""Fold"" (ftHgnone)"""
"""""","""-F <field name>""","""-F <tB[h>"""
"""""","""DatabaseResultProducer: setting additional ""","""DatabaseResultProducer: ݒAǉ"""
"""""","""Set the result producer to use. If some results are not found ""","""gp錋ʃvf[T[ݒDC̌ʂƂȂf[^x[XŌȂꍇ́C"""
"""""","""in the source database then this result producer is used to generate ""","""ʃvf[T[𐶐ɗp܂D"""
"""""","""them.""",""" """
"""""","""DatabaseResultProducer: """,""""""
"""""","""Experiment_index""",""""""
"""""","""Experiment_type""",""""""
"""""","""Experiment_setup""",""""""
"""""","""Result_table""",""""""
"""""","""DOUBLE PRECISION""",""""""
"""""","""Unknown data type: ""","""m̃f[^^: """
"""""",""". Add entry ""","""DȉɃGg[ĂD"""
"""""","""in weka/experiment/DatabaseUtils.props.""",""""""
"""""","""INT""",""""""
"""""","""jdbcDriver""",""""""
"""""","""No jdbc drivers specified""","""ǂjdbchCo[肳܂ł"""
"""""","""Added driver: ""","""hCo[ǉ: """
"""""","""jdbcURL""",""""""
"""""","""CREATE_STRING""",""""""
"""""","""CREATE_INT""",""""""
"""""","""CREATE_DOUBLE""","""""
"""""","""checkUpperCaseNames""",""""""
"""""","""setAutoCommit""",""""""
"""""","""createIndex""",""""""
"""""","""BIGINT ""","""""",""""""
"""""","""BINARY""","""""",""""""
"""""","""BIT""","""""",""""""
"""""","""CHAR""","""""",""""""
"""""","""DATE""","""""",""""""
"""""","""DECIMAL""","""""",""""""
"""""","""DOUBLE""","""""",""""""
"""""","""FLOAT""","""""",""""""
"""""","""INTEGER""","""""",""""""
"""""","""LONGVARBINARY""",""""""
"""""","""LONGVARCHAR""",""""""
"""""","""NUMERIC""","""""",""""""
"""""","""OTHER""","""""",""""""
"""""","""REAL""","""""",""""""
"""""","""SMALLINT""",""""""
"""""","""TIME""","""""",""""""
"""""","""TIMESTAMP""","""""",""""""
"""""","""TINYINT""",""""""
"""""","""VARBINARY""",""""""
"""""","""VARCHAR""",""""""
"""""","""Set the URL to the database.""","""f[^x[XURLݒ"""
"""""","""Connecting to ""","""ڑ܂D"""
"""""","""Disconnecting from ""","""Af܂D"""
"""""","""Checking if table ""","""e[u`FbN܂D"""
"""""",""" exists...""",""" ݂Ă܂c"""
"""""","""This table seems to exist more than once!""","""̃e[u͈x肳ɑ݂悤Ɏv܂!"""
"""""",""" exists""",""" ݂Ă܂D"""
"""""",""" does not exist""",""" ݂Ă܂D"""
"""""","""SELECT Key_Run""","""""",""""""
"""""","""Key names and key values of different lengths""","""قȂ̎vȖOƎvȒl"""
"""""",""" AND ""","""""",""" """
"""""","""Couldn't execute query: ""","""vss\: """
"""""","""No result for query: ""","""vւ̌ʂ܂: """
"""""","""Unhandled SQL result type (field ""","""SQLʃ^CvUnhandledA("""
"""""","""More than one result entry ""","""1ȏ̌ʃGg["""
"""""","""for result key: ""","""ʃL[̂߂: """
"""""",""" VALUES ( ""","""""",""" lA("""
"""""","""res: """,""""""
"""""","""Submitting result: ""","""o: """
"""""","""...acceptResult returned resultset""","""....acceptResultresultsetԂ܂B"""
"""""","""NULL""","""""","""k"""
"""""","""Creating experiment index table...""","""쐬āAe[uɍĂc"""
"""""",""" TEXT,""","""""",""""""
"""""",""" INT )""","""""",""""""
"""""","""Creating experiment index entry...""","""쐬āAGg[ɍĂc"""
"""""","""LOCK TABLES ""","""""",""""""
"""""",""" WRITE""","""""",""""""
"""""","""LOCKING TABLE""","""""",""""""
"""""","""SELECT COUNT(*) FROM ""","""""",""""""
"""""","""...getting number of rows""","""....s̐𓾂܂B"""
"""""","""INSERT INTO ""","""""",""""""
"""""",""" VALUES ('""","""""",""""""
"""""","""UNLOCK TABLES""","""""",""""""
"""""","""UNLOCKING TABLE""","""""",""""""
"""""","""Problem adding experiment index entry""","""CfbNXGg邱Ƃɂ"""
"""""","""DROP TABLE ""","""""",""""""
"""""","""Getting results table name...""","""ʂ̃e[u擾c"""
"""""","""SELECT ""","""""",""""""
"""""",""" FROM ""","""""",""""""
"""""",""" WHERE ""","""""",""""""
"""""","""' AND ""","""""","""'A'"""
"""""","""More than one index entry ""","""1ȏ̃CfbNXGg"""
"""""","""for experiment config: ""","""RtBÔ߂: """
"""""","""...results table = ""","""....ʂ=e[ȕɒu܂B"""
"""""","""<null>""",""""""
"""""","""Creating results table ""","""ʂe[ȕɒu쐬"""
"""""","""CREATE TABLE ""","""""",""""""
"""""","""key names types differ in length""","""vȖO^Cv͒ɂĈقȂ܂B"""
"""""","""result names and types differ in length""","""ʖƃ^Cv͒ɂĈقȂ܂B"""
"""""","""Mark Matthews' MySQL Driver""","""}[NE}V[YMySQLhCo["""
"""""","""InstantDB JDBC Driver""","""InstantDB JDBChCo["""
"""""","""TEXT ""","""""",""""""
"""""","""LONGVARCHAR ""","""""",""""""
"""""","""Unknown/unsupported field type in key""","""L[̖ḿA܂́AT|[gȂtB[hE^Cv"""
"""""","""...create returned resultset""","""....Ԃꂽresultset쐬ĂB"""
"""""","""table created""","""쐬ꂽe[u"""
"""""","""CREATE UNIQUE INDEX Key_IDX ON """,""""""
"""""",""",Key_""","""""",""""""
"""""","""...create index returned resultset""","""....CfbNX̕Ԃꂽresultset쐬ĂB"""
"""""","""Null array for property iterator""","""̌JԂq̂߂̃kz"""
"""""","""Lower run number is greater than upper run number""","""̎ԍ͏㑤̎ԍ傫łB"""
"""""","""No datasets have been specified""","""f[^Zbg͑Sw肳Ă܂B"""
"""""","""measure""",""""""
"""""","""Additional measures in ""","""̒ǉ[u"""
"""""",""" must obey the naming convention""",""" K{͖Kɏ]܂B"""
"""""",""" of starting with ""measure""""",""" uuvvn߂̂ɂ"""
"""""","""\tThe lower run number to start the experiment from.\n""","""\tThe. \nn߂邽߂Ɏԍ܂B"""
"""""","""\t(default 1)""","""\t(ftHg1)"""
"""""","""\tThe upper run number to end the experiment at (inclusive).\n""",""".. (I)\nŎI点\tThe㑤̎ԍ"""
"""""","""-U <num>""","""-U <num>"""
"""""","""\tThe dataset to run the experiment on.\n""",""".. \n̎𑖂点\tThef[^Zbg"""
"""""","""\t(required, may be specified multiple times)""","""\t(Kvł邱ƂŁẢw肳邩ȂȂĂ)"""
"""""","""-T <arff file>""","""-T<arfft@C>"""
"""""","""\tThe full class name of a ResultProducer (required).\n""","""ResultProducer(Kvł)\n\tThe̊SȃNX"""
"""""","""\teg: weka.experiment.RandomSplitResultProducer""","""\t: weka.experiment.RandomSplitResultProducer"""
"""""","""-P <class name>""","""-P <NX>"""
"""""","""\tThe full class name of a ResultListener (required).\n""","""ResultListener(Kvł)\n\tThe̊SȃNX"""
"""""","""\teg: weka.experiment.CSVResultListener""","""\t: weka.experiment.CSVResultListener"""
"""""","""-D <class name>""","""-D <NX>"""
"""""","""\tA string containing any notes about the experiment.\n""","""\tAɊւĒӂܗLԁA\n"""
"""""","""-N <string>""","""-N <>"""
"""""","""class_name""","""NX_O"""
"""""","""weka.experiment.CSVResultListener -O outfile.csv""","""weka.experiment.CSVResultListener -O outfile.csv"""
"""""","""Lower (""","""A("""
"""""",""") is greater than upper (""",""") 㑤ł肷΂炵("""
"""""","""Required: -T <arff file name>""","""Kv: -T <arfft@C>"""
"""""","""Required: -D <ResultListener class name>""","""Kv: -D <ResultListenerNX>"""
"""""","""Required: -P <ResultProducer class name>""","""Kv: -P <ResultProducerNX>"""
"""""","""Runs from: ""","""ȉ̑s """
"""""","""Custom property iterator: ""","""JX^̌JԂq: """
"""""","""off""","""It"""
"""""","""*** null propertyPath ***""","""*** kpropertyPath***"""
"""""","""*** null propertyArray ***""","""*** kpropertyArray***"""
"""""","""Custom property path:\n""","""JX^̌oH: \n"""
"""""","""Custom property name:""","""JX^̖:"""
"""""","""Custom property values:\n""","""JX^̒l: \n"""
"""""","""ResultProducer: """,""""""
"""""","""ResultListener: """,""""""
"""""","""Notes: """,""": """
"""""","""-l <exp|xml file>\n""","""-l <exp| xmlt@C>\n"""
"""""","""\tLoad experiment from file (default use cli options).\n""","""\tLoad̓t@C(ftHgcliIvVgp)\n܂B"""
"""""","""-s <exp|xml file>\n""","""-s<exp| xmlt@C>\n"""
"""""","""\tSave experiment to file after setting other options.\n""","""\tSavéÃIvV\nݒ肵Ƀt@C邽߂Ɏ܂B"""
"""""","""\tThe type is determined, based on the extension (""","""tThe^Cv\gɊÂĒfłƂĂA("""
"""""",""" or .xml)\n""",""" .xml) ܂́A\n"""
"""""","""\tRun experiment (default don't run)\n""","""\tRun\n܂(ftHg͉ғĂ܂)B"""
"""""","""SELECT * from ?""","""""","""*I܂?"""
"""""","""\tSQL query to execute.""","""s\tSQLB"""
"""""","""-Q <query>""","""-Q<₵܂>"""
"""""","""\tReturn sparse rather than normal instances.""","""\tReturn̐łƂނ܂΂ȗB"""
"""""","""\tThe username to use for connecting.""","""ڑ̂Ɏgp\tThe[UB"""
"""""","""-U <username>""","""-U<[U>"""
"""""","""\tThe password to use for connecting.""","""ڑ̂Ɏgp\tThepX[hB"""
"""""","""-P <password>""","""-P<pX[h>"""
"""""","""The SQL query to execute against the database.""","""f[^x[Xɑ΂ĎsSQLB"""
"""""","""Encode data as sparse instances.""","""܂΂ȃCX^XƂāAf[^ÍĂB"""
"""""","""Executing query: ""","""s̃NG: """
"""""","""Query didn't produce results""","""NG͌ʂ̍s"""
"""""",""" rows affected.""",""" ł܂łD"""
"""""","""Getting metadata...""","""^f[^擾c"""
"""""","""Completed getting metadata...""","""^f[^̎擾c"""
"""""","""String --> nominal""","""String --> `^"""
"""""","""boolean --> nominal""","""boolean --> `^"""
"""""","""BigDecimal --> numeric""","""BigDecimal --> l^"""
"""""","""byte --> numeric""","""byte --> l^"""
"""""","""short --> numeric""","""short --> l^"""
"""""","""int --> numeric""","""int --> l^"""
"""""","""long --> numeric""","""long --> l^"""
"""""","""float --> numeric""","""float --> l^"""
"""""","""Unknown column type""","""m̑^Cv"""
"""""","""Creating instances...""","""CX^X쐬c"""
"""""","""read ""","""ǂݍ"""
"""""",""" instances \r""",""" CX^X\r"""
"""""","""Creating header...""","""wb_[쐬c"""
"""""","""QueryResult""",""""""
"""""","""select * from Experiment_index""","""""","""Experiment_CfbNX*IĂB"""
"""""","""Options for weka.experiment.InstanceQuery:\n""","""weka.experiment.InstanceQuerŷ߂̃IvV: \n"""
"""""","""Takes results from a result producer and assembles them into ""","""ʃvf[T[猋ʂ󂯎āC"""
"""""","""a set of instances.""","""1̃CX^XWƂ܂D"""
"""""","""Unknown attribute type in column ""","""R̖m̑^Cv"""
"""""","""Key_""","""""","""v_"""
"""""","""Unknown attribute type""","""m̑^Cv"""
"""""","""InstanceResultListener""",""""""
"""""","""Total_instances""","""v_"""
"""""","""Tells a sub-ResultProducer to reproduce the current run for ""","""₳ꂽdĐ悤ɃTuResultProducerɌ܂B"""
"""""","""varying sized subsamples of the dataset. Normally used with ""","""قȂ̂̓f[^Zbǵu-Tvv傫ŕ܂B ʏAgpĂ܂B"""
"""""","""an AveragingResultProducer and CrossValidationResultProducer ""","""AveragingResultProducerCrossValidationResultProducer"""
"""""","""combo to generate learning curve results.""","""[jOJ[u𔭐R{͌ʂƂĐ܂B"""
"""""","""No ResultProducer set""","""ǂResultProducerZbg܂łB"""
"""""","""Unrecognized ResultProducer sending results!!""","""FĂȂResultProducert!"""
"""""","""Dev_""","""""",""""""
"""""","""Avg_""",""""""
"""""","""<null ResultProducer>""","""<kResultProducer>"""
"""""","""\tThe number of steps in the learning rate curve.\n""","""\twKȐ̃Xebv\n"""
"""""","""\t(default 10)""","""\t(ftHg10)"""
"""""","""-X <num steps>""","""-X <Xebv>"""
"""""","""\tThe full class name of a ResultProducer.\n""","""\tResultProducer̊SȃNX"""
"""""","""\teg: weka.experiment.CrossValidationResultProducer""","""\t : weka.experiment.CrossValidationResultProducer"""
"""""","""\nOptions specific to result producer ""","""\nʃvf[T[L̃IvV"""
"""""","""A ResultProducer must be specified with""","""ResultProducerƋɎw肵Ȃ΂Ȃ܂B"""
"""""","""LearningRateResultProducer: setting additional ""","""LearningRateResultProducer: ݒAǉ"""
"""""","""ResultProducer""",""""""
"""""","""Set the minmum number of instances in a dataset. Setting zero ""","""f[^Zbg̗minmumԍݒ肵ĂB [ݒ肵܂B"""
"""""","""here will actually use <stepSize> number of instances at the first ""","""ŁAۂ1Ԗڂŗ<stepSize>ԍgpł傤B"""
"""""","""step (since it makes no sense to use zero instances :-))""","""ł(gpȂӖɑSȂ̂ŁÃ[킹Ă(^o^))B"""
"""""","""Set the maximum number of instances in a dataset. Setting -1 ""","""f[^Zbg̗̍ő吔ݒ肵ĂB ݒ-1"""
"""""","""sets no upper limit (other than the total number of instances ""","""Sݒ肵ȂA(̑"""
"""""","""in the full dataset)""","""ASȃf[^Zbg)"""
"""""","""Set the number of instances to add at each step.""","""̐ɊeXebvŉ悤ɐݒ肵ĂB"""
"""""","""Set the resultProducer for which learning rate results should be ""","""[gʂǂ̊wKłׂł邩resultProducerݒ肵ĂB"""
"""""","""generated.""","""B"""
"""""","""LearningRateResultProducer: """,""""""
"""""","""Here is some test text to be zipped""","""ɁA炩̃t@Xi[ŕ߂ׂłeXgeLXg܂B"""
"""""","""testzip""",""""""
"""""","""Here is a second entry to be zipped""","""ɁA2Ԗڂ̃t@Xi[ŕ߂ׂłGg[܂B"""
"""""","""testzip2""",""""""
"""""","""number_of_training_instances""","""_g[jO_̐_"""
"""""","""number_of_testing_instances""","""_eXg_̐_"""
"""""","""Analysis for """,""""""
"""""",""" points:\n""",""" |Cg: \n"""
"""""","""         Column 1""",""" R1"""
"""""","""         Column 2""",""" R2"""
"""""","""       Difference\n""",""" Ⴂ\n"""
"""""","""Minimums        ""","""ŏ"""
"""""","""Maximums        ""","""ő"""
"""""","""Sums            ""","""v"""
"""""","""SumSquares      ""","""SumSquares"""
"""""","""Means           ""","""i"""
"""""","""SDs             ""","""SDs"""
"""""","""Prob(differences) ""","""Prob(Ⴂ) """
"""""",""" (sigflag """,""" (sigflag"""
"""""","""Correlation       ""","""֊֌W"""
"""""","""Inference for the Generalization Error,""","""ʉ̂߂̐_"""
"""""","""No instances have been set""","""CX^X͑Sݒ肳Ă܂B"""
"""""","""No result specifier columns have been set""","""ʓ̍쐬R͑Sݒ肳Ă܂B"""
"""""","""No dataset specifier columns have been set""","""f[^Zbg̍쐬R͑Sݒ肳Ă܂B"""
"""""","""Instance has missing value in run ""","""CX^Xɂ́Asɂ錇l܂B"""
"""""","""Instance has missing value in resultset key ""","""CX^XresultsetL[ɌlĂ܂B"""
"""""","""Instance has missing value in dataset key ""","""CX^X̓f[^ZbgL[ɌlĂ܂B"""
"""""","""column ""","""R"""
"""""","""Comparison column ""","""rR"""
"""""",""") is not numeric""",""") lł͂܂B"""
"""""","""No results for dataset=""","""f[^Zbg=̂߂̌ʂ܂B"""
"""""",""" for resultset=""",""" resultset=̂߂"""
"""""","""Results for dataset=""","""f[^Zbg=̂߂̌"""
"""""",""" differ in size for resultset=""",""" resultset=̂߂̃TCYł́AقȂĂB"""
"""""",""" and resultset=""",""" āAresultset="""
"""""","""Instance has missing value in comparison ""","""ɂ́Arɂ錇l܂B"""
"""""","""column!\n""","""R! \n"""
"""""","""Run numbers do not match!\n""","""ԍ\nɍ܂B"""
"""""","""Fold numbers do not match!\n""","""܂ڂ̔ԍ\nɍ܂B"""
"""""","""Differences stats:\n""","""Ⴂ̓v: \n"""
"""""","""header""","""wb_["""
"""""","""Analysing:  ""","""͂܂: """
"""""","""Datasets:   ""","""f[^Zbg: """
"""""","""Resultsets: """,""""""
"""""","""Confidence: ""","""Mp: """
"""""",""" (two tailed)\n""",""" (2ɂčs܂)\n"""
"""""","""Date:       ""","""t: """
"""""","""Comparing (""","""˂킹("""
"""""",""") with (""",""") ("""
"""""","""{\\centering\n""","""\n𒆐Sɒu{\\"""
"""""","""\\begin{tabular}{l""","""\\{\}{ln߂܂B"""
"""""","""}\\\\\n\\hline\n""","""}\\\\\n~\hline\n"""
"""""",""" \\\\\n\\hline\n""",""" \\\\\n~\hline\n"""
"""""","""  (No. of datasets where [col] >> [row])\n""",""" (Af[^ZbgɂĂǂA>A)\n"""
"""""","""\\hline\n\\end{tabular} \\footnotesize \\par\n\\end{table}}""","""\\hline\n~\I{\}\\͕\n~\I点{e[ȕɒu܂}\\footnotesize܂B"""
"""""","""\\begin{table}[thb]\n\\caption{\\label{labelname}Table Caption""","""\\{e[ȕɒu܂}thb\n\\o{\\x{labelname} e[uon߂܂B"""
"""""","""}\n\\footnotesize\n{\\centering \\begin{tabular}{rlll}\\\\\n\\hline\n""","""}\n~\\n\n{\\𒆐Sɒu\\\{n߂܂}{rlll}\\\\\n~\hline}footnotesize܂B"""
"""""","""Resultset & Wins$-$ & Wins & Losses \\\\\n& Losses & & ""","""ResultsetA$-$ƏAё\\\\\nƑ"""
"""""",""" Resultset\n""",""""""
"""""","""\\hline\n\\end{tabular} \\footnotesize \\par}\n\\end{table}""","""\\hline\n~\I{\}\\͕} \n~\I点\\footnotesize܂B{eȕɒu܂}"""
"""""","""\\begin{table}[thb]\n\\caption{\\label{labelname}""","""\\{\\xn~{e[ȕɒu܂}thb\\on߂܂B{labelname}"""
"""""","""Table Caption}\n""","""e[uo} \n"""
"""""","""\\footnotesize\n""","""\\\nfootnotesize܂B"""
"""""","""\\scriptsize\n""","""\\\nscriptsize܂B"""
"""""","""{\\centering \\begin{tabular}{ll""","""{\\𒆐Sɒu\\{\}{lln߂܂B"""
"""""","""{\\centering \\begin{tabular}{lr@{\\hspace{0cm}}l""","""{\\𒆐Sɒu\\{\}{lr@{\\hspace{0cm}n߂܂} l"""
"""""","""r@{\\hspace{0cm}}l@{\\hspace{0cm}}r""",""""""
"""""","""}\n\\\\\n\\hline\n""","""}\An\\\\\n~~hline\n"""
"""""","""Data Set & (""","""f[^ZbgA("""
"""""","""Data Set & \\multicolumn{2}{c}{(""","""f[^Zbg\\multicolumn{2}{c}{A("""
"""""","""& \\multicolumn{3}{c}{(""","""\\multicolumn{3}{c}{A("""
"""""","""\\\\\n\\hline\n""","""\\\\\n~\hline\n"""
"""""","""$\\circ$  ""","""$\\circ$"""
"""""","""$\\bullet$""","""$\\eہA$"""
"""""","""\\hline\n\\multicolumn{""","""\\hline\n\\u}`-Rv{"""
"""""","""}{c}{$\\circ$, $\\bullet$""","""}{c}{$\\$circāA$\\eۂ$łB"""
"""""",""" statistically significant improvement or degradation}""",""" vIɌȉǂލs}"""
"""""","""\\\\\n\\end{tabular} ""","""\\\\\n~\͏I܂B{\}"""
"""""","""\\footnotesize ""","""\\footnotesize܂B"""
"""""","""\\scriptsize ""","""\\scriptsize܂B"""
"""""","""\\par}\n\\end{table}""","""\\} \n~\͏I܂B{e[ȕɒu܂}"""
"""""","""Inf""",""""""
"""""","""Skipped: ""","""XLbv: """
"""""","""\tdataset.\n""","""\. \ntdataset܂B"""
"""""","""-D <index,index2-index4,...>""","""-D<CfbNXAindex2-index4>"""
"""""","""\tSet the index of the column containing the run number""","""\tSet͎ԍ܂ރR̃CfbNXłB"""
"""""","""-R <index>""","""-R<܂>"""
"""""","""\tSet the index of the column containing the fold number""","""\tSet͐܂ڂ̔ԍ܂ރR̃CfbNXłB"""
"""""","""-F <index>""","""-F<܂>"""
"""""","""\tSpecify list of columns that specify a unique\n""","""\̓j[N\nw肷R̃XgtSpecify܂B"""
"""""","""\t'result generator' (eg: classifier name and options).\n""","""'\t'resultWFl[^'(eg: NVt@CAƃIvV)\n"""
"""""","""\tFirst and last are valid indexes. (default none)""","""\tFirstƍŏI͗LȃCfbNXłB (ȂɂɁAftHgƂ܂)"""
"""""","""-G <index1,index2-index4,...>""","""-G<index1Aindex2-index4>"""
"""""","""\tSet the significance level for comparisons (default 0.05)""","""\tSet͔r̂߂̗LӐłB(ftHg0.05)"""
"""""","""-S <significance level>""","""-S<LӐ>"""
"""""","""\tShow standard deviations""","""\tShowW΍"""
"""""","""\tProduce table comparisons in Latex table format""","""\tProduceLatexe[u`ɂr܂B"""
"""""","""\tProduce table comparisons in CSV table format""","""\tProduceCSVe[u`ɂr܂B"""
"""""","""-csv""",""""""
"""""","""-t and -c options are required""","""-tāA-cIvVKvłB"""
"""""","""-t <file>\n""","""-t<t@C܂>\n"""
"""""","""\tSet the dataset containing data to evaluate\n""","""\tSet\n]f[^܂ރf[^ZbgłB"""
"""""","""-b <index>\n""","""-b<܂>\n"""
"""""","""\tSet the resultset to base comparisons against (optional)\n""","""\tSet(C)\nɑ΂ĔrbÂresultsetłB"""
"""""","""-c <index>\n""","""-c<܂>\n"""
"""""","""\tSet the column to perform a comparison on\n""","""\tSet\nɔrsRłB"""
"""""","""\tSummarize wins over all resultset pairs\n\n""","""\ׂ͂Ăresultsetg\n\n̏ŏtSummarize܂B"""
"""""","""\tGenerate a resultset ranking\n\n""","""\tGenerate\n\nłƊitresultsetłB"""
"""""","""Available properties""","""p\ȓ"""
"""""","""Can't serialize object: ""","""IuWFNgAڂ邱Ƃł܂: """
"""""","""Loading property descriptor:\n""","""[fBŐLqq: \n"""
"""""","""\tparentClass: """,""""""
"""""","""\tname: """,""""""
"""""","""\tgetter: """,""""""
"""""","""\tsetter: """,""""""
"""""","""Couldn't create property descriptor: ""","""̋Lqq쐬邱Ƃł܂ł: """
"""""","""Dataset""","""f[^Zbg"""
"""""","""Date_time""","""t_"""
"""""","""Performs a random train and test using a supplied ""","""ꂽagp邱ƂŖׂ̗ԂƃeXgs܂B"""
"""""","""evaluator.""","""]ҁB"""
"""""","""RandomSplitResultProducer: setting additional ""","""RandomSplitResultProducer: ݒAǉ"""
"""""","""measures for ""","""肵܂B"""
"""""","""split evaluator""","""]"""
"""""","""UTC""",""""""
"""""","""No SplitEvalutor set""","""ǂSplitEvalutorZbg܂łB"""
"""""","""No ResultListener set""","""ǂResultListenerZbg܂łB"""
"""""","""No Instances set""","""ǂInstancesZbg܂łB"""
"""""",""" <null SplitEvaluator>""",""" <kSplitEvaluator>"""
"""""","""Set the destination for saving raw output. If the rawOutput ""","""̏o͂Ă̂ɖړInݒ肵ĂB rawOutputłB"""
"""""","""option is selected, then output from the splitEvaluator for ""","""IvV́AIāAɁAsplitEvaluatoro͂܂B"""
"""""","""individual train-test splits is saved. If the destination is a ""","""X̗ԃeXgҊ͋~܂B ړInałȂ"""
"""""","""directory, ""","""fBNg"""
"""""","""then each output is saved to an individual gzip file; if the ""","""ɁAeo͂͌Xgzipt@Cɕۑ܂; the"""
"""""","""destination is a file, then each output is saved as an entry ""","""ړInt@CłAāAeo͂̓Gg[ƂĎĂ܂B"""
"""""","""in a zip file.""","""Wbvt@CŁB"""
"""""","""Do not randomize dataset and do not perform probabilistic rounding ""","""f[^Zbg_}CYȂłAāAmIȈsȂłB"""
"""""","""if true""","""{"""
"""""","""Save raw output (useful for debugging). If set, then output is ""","""̏o(fobO̖ɗ)ĂĂB ݒ肳ȂAo͂͂łB"""
"""""","""sent to the destination specified by outputFile""","""outputFileɂĎw肳ꂽړInɔM܂B"""
"""""","""Set the percentage of data to use for training.""","""g[jOɎgpf[^̊ݒ肵ĂB"""
"""""","""The evaluator to apply to the test data. ""","""eXgf[^ɓKp]ҁB"""
"""""","""This may be a classifier, regression scheme etc.""","""͕AvNVt@CAł邩܂ȂǁB"""
"""""","""\tThe percentage of instances to use for training.\n""","""g[jO\nɎgp\tThe"""
"""""","""\t(default 66)""","""\t(ftHg66)"""
"""""","""Save raw split evaluator output.""","""̕]ҏo͂ĂĂB"""
"""""","""\tThe filename where raw output will be stored.\n""","""̏o͂i[\tThet@CA\n"""
"""""","""\tIf a directory name is specified then then individual\n""","""\tIf afBNg͎w肳ꂽ̓̌X\nłB"""
"""""","""\toutputs will be gzipped, otherwise all output will be\n""","""\toutputsgzippedł傤BȂ΁AׂĂ̏o͂\ɂȂł傤nB"""
"""""","""\tzipped to the named file. Use in conjuction with -D.""","""\͎w肳ꂽt@Ctzipped܂B conjuctionł́A-DƋɎgp܂B"""
"""""","""\t(default splitEvalutorOut.zip)""","""\t(ftHgsplitEvalutorOut.zip)"""
"""""","""-O <file/directory name/path>""","""-O<t@C/fBNg/oH>"""
"""""","""\tThe full class name of a SplitEvaluator.\n""","""SplitEvaluator\n\tThe̊SȃNX"""
"""""","""\teg: weka.experiment.ClassifierSplitEvaluator""","""\2Nڂ̗r: weka.experiment.ClassifierSplitEvaluator"""
"""""","""\tSet when data is not to be randomized and the data sets' size.\n""","""TCYf[^_}CYȂƂłAf[^Zbĝ̂\nł\tSet"""
"""""","""\tIs not to be determined via probabilistic rounding.""","""mIȈʂĒfłƂȂ\tIsB"""
"""""","""\nOptions specific to split evaluator ""","""]҂𕪂邽߂ɓ\nOptions"""
"""""","""A SplitEvaluator must be specified with""","""SplitEvaluatorƋɎw肵Ȃ΂Ȃ܂B"""
"""""","""RandomSplitResultProducer: """,""""""
"""""",""": <null Instances>""",""": <k>"""
"""""","""A SplitEvaluator that produces results for a classification ""","""ނ̂߂ɌSplitEvaluator"""
"""""","""scheme on a numeric class attribute.""","""lNXŌv悵ĂB"""
"""""","""\tThe full class name of the classifier.\n""","""NVt@CA\tThe̊SȃNXA\n"""
"""""","""\teg: weka.classifiers.bayes.NaiveBayes""","""\2Nڂ̗r: weka.classifiers.bayes.NaiveBayes"""
"""""","""-W <class name>""","""-W<NX>"""
"""""","""\nOptions specific to classifier ""","""NVt@CAɁA\nOptions"""
"""""","""A classifier must be specified with""","""NVt@CAŁAw肵Ȃ΂Ȃ܂B"""
"""""",""" the -W option.""",""" -WIvVB"""
"""""","""Can't return result for measure, ""","""̂߂ɌʂԂƂł܂B"""
"""""","""classifier has not been built yet.""","""NVt@CA͂܂gĂĂ܂B"""
"""""","""ClassifierSplitEvaluator: """,""""""
"""""","""Can't return value for : ""","""ȉ̂߂ɒlԂƂł܂B """
"""""","""is not an AdditionalMeasureProducer""","""AdditionalMeasureProducerł͂܂B"""
"""""","""Scheme""","""v"""
"""""","""Scheme_options""","""v_IvV"""
"""""","""Scheme_version_ID""","""v_o[W_ID"""
"""""","""ResultTypes didn't fit RESULT_SIZE""","""ResultTypesRESULT_SIZEɍ܂łB"""
"""""","""Number_of_instances""","""_̐_"""
"""""","""Mean_absolute_error""","""Ӓn__"""
"""""","""Root_mean_squared_error""","""_́A__悵̂Ӗ܂B"""
"""""","""Relative_absolute_error""","""ΓI__"""
"""""","""Root_relative_squared_error""","""_e__悵܂B"""
"""""","""Correlation_coefficient""","""֊֌W_W"""
"""""","""SF_prior_entropy""","""SF_̐_Ggs["""
"""""","""SF_scheme_entropy""","""SF_v_Ggs["""
"""""","""SF_entropy_gain""","""SF_Ggs[_"""
"""""","""SF_mean_prior_entropy""","""_SF̕_̐_Ggs["""
"""""","""SF_mean_scheme_entropy""","""SF__v_Ggs["""
"""""","""SF_mean_entropy_gain""","""SF__Ggs[_"""
"""""","""Time_training""","""_g[jO"""
"""""","""Time_testing""","""_eXg"""
"""""","""ResultNames didn't fit RESULT_SIZE""","""ResultNamesRESULT_SIZEɍ܂łB"""
"""""","""Class attribute is not numeric!""","""NX͐lł͂܂!"""
"""""","""No classifier has been specified""","""NVt@CA͑Sw肳Ă܂B"""
"""""","""Results didn't fit RESULT_SIZE""","""ʂRESULT_SIZEɍ܂łB"""
"""""","""The classifier to use.""","""gpNVt@CAB"""
"""""","""RegressionSplitEvaluator: In set classifier""","""RegressionSplitEvaluator: ZbgNVt@CA"""
"""""","""Can't find Classifier with class name: ""","""NXClassifier͌邱Ƃł܂: """
"""""","""Classifier model: \n""","""NVt@CAf: \n"""
"""""","""RegressionSplitEvaluator: """,""""""
"""""","""<null> classifier""","""<k>̃NVt@CA"""
"""""","""(version ""","""(o[W"""
"""""","""local""","""[J"""
"""""","""RemoteEngine : purge - no tasks to check.""","""RemoteEngine: Ă--`FbN^XN܂B"""
"""""",""") : Task not found.""",""") : Ȃ^XNB"""
"""""","""Finished/failed Task id : ""","""IĂ邩sTaskCh: """
"""""",""" checked by client. Removing.""",""" NCAgɂă`FbN܂B OB"""
"""""",""") : task queued at postion: """,""") : ^XNpostionɗ܂: """
"""""","""Task id : ""","""ChɎdۂĂ: """
"""""","""Queued.""","""ɕ΂B"""
"""""",""") : task running...""",""") : sɎdۂĂc"""
"""""","""Launching task id : ""","""˃^XNCh: """
"""""","""RemoteExperiment (""","""RemoteExperimentA("""
"""""","""RemoteEngine (""","""RemoteEngineA("""
"""""",""") : task failed.""",""") : ^XN͎s܂B"""
"""""","""Task id ""","""^XNCh"""
"""""","""Failed!""","""sɂ!"""
"""""","""RemoteEngine purge. Current time : ""","""RemoteEngine͏܂B ݂̎: """
"""""","""Examining task id : ""","""^XNCh𒲂ׂ܂: """
"""""","""\nTask id : ""","""\nTaskCh: """
"""""",""" has gone stale. Removing.""",""" ÂłȂ܂B OB"""
"""""","""Host name : ""","""OzXeBOĂ: """
"""""","""RemoteEngine exception: ""","""RemoteEngineO: """
"""""","""Attempting to start rmi registry...""","""rmio^n߂݂̂܂c"""
"""""","""RemoteEngine bound in RMI registry""","""RemoteEngineRMIo^ŃoEhĂ܂B"""
"""""","""codebase""",""""""
"""""","""Base experiment is null!""","""n̎̓kł!"""
"""""","""No base experiment specified!""","""x[X͑Sw肵܂ł!"""
"""""","""Experiment aborted! All connections ""","""͒~ɂȂ܂! ׂĂ̐ڑ"""
"""""",""" data sets""",""" f[^Zbg"""
"""""",""" runs""",""" s"""
"""""",""" completed successfully. """,""" 悭܂B"""
"""""",""" failures during running.\n""",""" s\n̊Ԃ̎s"""
"""""","""Experiment aborted! Max failures ""","""͒~ɂȂ܂! }bNX̎s"""
"""""","""Experiment completed successfully.""","""悭IB"""
"""""","""Experiment aborted. All remote tasks ""","""͒~ɂȂ܂B ׂẴ[g^XN"""
"""""","""dataset :""","""f[^Zbg:"""
"""""","""run :""","""ȉsĂB"""
"""""","""Starting ""","""n܂܂B"""
"""""",""" failed. Scheduling """,""" sɂB XPW[O"""
"""""","""\nRemote Hosts:\n""","""nRemoteڑ҂\: \n"""
"""""","""-l <exp file>\n""","""-l<expt@C>\n"""
"""""","""\tLoad experiment from file (default use cli options)\n""","""\tLoad̓t@C(ftHgcliIvVgp)\n܂B"""
"""""","""-s <exp file>\n""","""-s<expt@C>\n"""
"""""","""\tSave experiment to file after setting other options\n""","""\tSavéÃIvV\nݒ肵Ƀt@C邽߂Ɏ܂B"""
"""""","""\t(default don't save)\n""","""\t(ftHg͕ۑ܂)\n"""
"""""","""-h <remote host name>\n""","""-h<[gzXg>\n"""
"""""","""\tHost to run experiment on (may be specified more than once\n""","""sւ\tHostA(x\nw肳邩܂B"""
"""""","""\tfor multiple remote hosts)\n""","""\tfor{[gȃzXg) \n"""
"""""","""\tRun experiment on (default don't run)\n""","""\tRun\n܂(ftHg͉ғĂ܂)B"""
"""""","""-xml <filename | xml-string>\n""","""-xml(<t@C| xml-XgO>)\n"""
"""""","""\tget options from XML-Data instead from parameters\n""","""tgetXML-f[^p^\n䂾˂\"""
"""""","""Not running.""","""܂B"""
"""""","""Running...""","""܂c"""
"""""","""(sub)experiment completed successfully""","""(㗝܂)悭I"""
"""""","""(dataset ""","""(f[^Zbg"""
"""""","""(exp run # ""","""(exps#"""
"""""","""Initializing ""","""lݒ"""
"""""","""Iterating ""","""JԂ"""
"""""","""Postprocessing ""","""㏈"""
"""""","""(sub)experiment ""","""(㗝܂)"""
"""""",""") failed : """,""") s: """
"""""","""Failed""","""s܂B"""
"""""","""No errors""","""肪܂B"""
"""""","""Warning: stdDev value = ""","""x: stdDevl="""
"""""",""" -- rounded to zero.""",""" -- [ɁA܂B"""
"""""","""Count   ""","""JEg"""
"""""","""Min     """,""""""
"""""","""Max     ""","""}bNX"""
"""""","""Sum     ""","""v"""
"""""","""SumSq   ""","""SumSq"""
"""""","""Mean    """,""""""
"""""","""StdDev  ""","""StdDev"""
"""""",""" ,\t\n\r\f""",""" \t\n~r\f"""
"""""","""MSG: Too many values in line """"","""MSG: ߂̂ŕ]Auv"""
"""""",""""", skipped.""","""uuXLbvĂAv"""
"""""","""New Task""","""V^XN"""
"""""","""classFirst""",""""""
"""""","""value""","""l"""
"""""","""parentClass""",""""""
"""""","""property""",""""""
"""""","""PropertyNode""",""""""
"""""","""An instance filter that passes all instances through unmodified.""","""ύXȂƂłׂẴCX^Xʉ߂CX^XtB^B"""
"""""",""" Primarily for testing purposes.""",""" ƂăeXgړÎ߂ɁB"""
"""""","""Instance has no dataset assigned!!""","""CX^XŁAf[^ZbgS蓖Ă܂!"""
"""""","""Src and Dest differ in # of attributes!!""","""SrcDest͑#Ƃ̂ɂĈقȂ܂!"""
"""""","""Src and Dest string indices differ in length!!""","""SrcDestXgOCfbNXXg͒ɂĈقȂ܂!"""
"""""",""" out:""",""" o:"""
"""""","""\t(use -b -h for help on batch mode.)\n""","""\t(Ƀob`E[h-b-hgpĂB)\n"""
"""""","""-i <file>\n""","""-i<t@C܂>\n"""
"""""","""\tThe name of the file containing input instances.\n""","""tThe̓CX^X\n܂ރt@C\"""
"""""","""\tIf not supplied then instances will be read from stdin.\n""","""tIf̎Ȃ\stdin\nǂ܂ł傤B"""
"""""","""-o <file>\n""","""-o<t@C܂>\n"""
"""""","""\tThe name of the file output instances will be written to.\n""","""tThet@Co̓CX^X\. \n܂ŏł傤B"""
"""""","""\tIf not supplied then instances will be written to stdout.\n""","""tIf̎Ȃ\stdout\n܂ŏł傤B"""
"""""","""Setting input format""","""̓tH[}bgݒ肵܂B"""
"""""","""Input instance to filter""","""tB^[ɂ̓CX^X"""
"""""","""Filter said collect immediately""","""ɗɎꂽtB^"""
"""""","""Setting end of batch""","""ob`̏I߂܂B"""
"""""","""Filter said collect output""","""Oq̗̏o͂tB^[ɂĂB"""
"""""","""Getting output format""","""o͌`l"""
"""""","""Getting output instance""","""o̓CX^Xl"""
"""""","""No first input file given.\n""","""ŏ̓̓t@C^Ă܂\n"""
"""""","""No second input file given.\n""","""Ԗڂ̓̓t@C^Ă܂\n"""
"""""","""Help requested.\n""","""wvv܂\n"""
"""""","""Input file formats differ.\n""","""̓t@C`قȂA\n"""
"""""","""\nFilter options:\n\n""","""\nFilter̃IvV: \n\n"""
"""""","""\nGeneral options:\n\n""","""\nʂ̃IvV: \n\n"""
"""""","""\tGet help on available options.\n""","""\tLȃIvṼwvl\n"""
"""""","""-i <filename>\n""","""-i <t@C>\n"""
"""""","""\tThe file containing first input instances.\n""","""\tt@C͍ŏ̓̓f[^Zbg܂ł܂\n"""
"""""","""-o <filename>\n""","""-o <t@C>\n"""
"""""","""\tThe file first output instances will be written to.\n""","""\tŏ̃f[^܂t@C\n"""
"""""","""-r <filename>\n""","""-r <t@C>\n"""
"""""","""\tThe file containing second input instances.\n""","""\t̓̓f[^Zbg܂ރt@C\n"""
"""""","""-s <filename>\n""","""-s <t@C>\n"""
"""""","""\tThe file second output instances will be written to.\n""","""\t̃f[^Zbg܂t@C\n"""
"""""","""-c <class index>\n""","""-c <NXԍ>\n"""
"""""","""\tThe number of the attribute to use as the class.\n""","""\tNXƂėp鑮̔ԍ\n"""
"""""","""\t""first"" and ""last"" are also valid entries.\n""","""\t""first""  ""last"" Ƃ\LLł\n"""
"""""","""\tIf not supplied then no class is assigned.\n""","""\tNX肳Ȃ΁C܂\n"""
"""""","""Filter didn't return true from setInputFormat() ""","""tB^͈ȑOsetInputFormat()"""
"""""","""earlier!""","""^ԂĂ܂I"""
"""""","""Filter didn't return true from""","""tB^͕ԂlƂĐ^𓾂܂"""
"""""",""" isOutputFormatDefined() earlier!""",""" ȑOisOutputFormatDefined()!"""
"""""","""First argument must be the class name of a Filter""","""擪̈̓tB^̃NXłȂ΂Ȃ܂"""
"""""","""A supervised attribute filter that can be used to select ""","""tttB^͑I邱Ƃł܂"""
"""""","""attributes. It is very flexible and allows various search ""","""͂ƂĂ_ł܂܂ȒT@"""
"""""","""and evaluation methods to be combined.""","""]@ƗZ邱Ƃ\ł"""
"""""","""\tSets search method for subset ""","""\tW]̂߂̒T@"""
"""""","""evaluators.""","""ݒ"""
"""""","""-S <""Name of search class""","""-S <""TNX̖O"""
"""""",""" [search options]"">""",""" [T̃IvV]"">"""
"""""","""\tSets attribute/subset evaluator.""","""\t邢͕W̕]@ݒ"""
"""""","""-E <""Name of attribute/subset ""","""-E <""邢͕W"""
"""""","""evaluation class [evaluator ""","""]NX []@"""
"""""","""options]"">""","""IvV]"">"""
"""""","""evaluator ""","""]@"""
"""""","""\nOptions specific to ""","""\nT@肷"""
"""""","""search ""","""IvV"""
"""""","""Name of search class [search options]""","""NXIvV̖O"""
"""""","""weka.attributeSelection.BestFirst -S 8""","""weka.attributeSelection.BestFirst -S 8"""
"""""","""Name of attribute/subset evaluation class [evaluator options]""","""܂͕W̕]@NX []@̃IvV]"""
"""""","""weka.attributeSelection.CfsSubsetEval -L""","""weka.attributeSelection.CfsSubsetEval -L"""
"""""","""Cross validation is not a valid option""","""͖ȃIvVƂȂ܂D"""
"""""",""" when using attribute selection as a Filter.""",""" IFilterƂĎgƂɂ́D"""
"""""","""Determines how attributes/attribute subsets are evaluated.""","""邢͑Wǂ̂悤ɕ]邩"""
"""""","""Determines the search method.""","""\bh"""
"""""","""No selected attributes\n""","""Iꂽ͂܂\n"""
"""""","""Changes the order of the classes so that the class values are ""","""NX̏ύX܂DȂȂC"""
"""""","""no longer of in the order specified in the header. ""","""łɃNXl̓wb_[̏Ƃē肳ĂȂ̂ŁD"""
"""""","""The values will be in the order specified by the user ""","""l̓[Uɂē肳ꂽɂȂ܂"""
"""""","""-- it could be either in ascending/descending order by the class ""","""-- ͏/~̂ǂ炩ɂȂ܂D"""
"""""","""frequency or in random order. Note that this filter currently does not ""","""NX̕pxׂ̏ŁD ̃tB^݂Ȃ"""
"""""","""change the header, only the class values of the instances, ""","""wb_[ACX^X̊KlςĂB"""
"""""","""so there is not much point in using it in conjunction with the ""","""Ɋ֘AĂāAgp邻قǑȂӖB"""
"""""","""FilteredClassifier.""",""""""
"""""","""\tSpecify the seed of randomization\n""","""\t_̎\n"""
"""""","""\tused to randomize the class\n""","""\tNX̏_̂߂ɗp\n"""
"""""","""\torder (default: 1)""","""\t@(ftHg: 1)"""
"""""","""-R <seed>""","""-R <>"""
"""""","""\tSpecify the class order to be\n""","""\t񂷂NX̏D\n"""
"""""","""\tsorted, could be 0: ascending\n""","""\tȉ̃IvV\łD0: \n"""
"""""","""\t1: descending and 2: random.(default: 0)""","""\t1: ~ 2: _@(ftHg: 0)"""
"""""","""-C <order>""","""-C <>"""
"""""","""Specify the seed of randomization of the class order""","""NX̏_̎w"""
"""""","""Specify the class order after the filtering""","""tB^ǑɃNX̏w"""
"""""","""ClassOrder: No class index set.""","""ClassOrder: NX̗ԍ܂"""
"""""","""ClassOrder: Class must be nominal.""","""ClassOrder: NX͖`łȂ΂Ȃ܂"""
"""""","""Class order not defined!""","""NX̏`Ă܂!"""
"""""","""Coverter table not defined yet!""","""Covertere[u͂܂`Ă܂ł!"""
"""""","""\tUse better encoding of split point for MDL.""","""\tMDL̂߂̕_ƂĂǂR[h𗘗p\n"""
"""""","""\tUse Kononenko's MDL criterion.""","""\tUse KononenkoMDL]𗘗p\n"""
"""""","""Cannot use class-based discretization: ""","""NXƂUs\: """
"""""","""no class assigned to the dataset""","""f[^ZbgɃNX蓖ĂĂ܂"""
"""""","""Supervised discretization not possible:""","""tt̗Us\: """
"""""",""" class is not nominal!""",""" NX`^ł͂܂!"""
"""""",""" Discretization is by Fayyad & Irani's MDL method (the default).""",""" UFayyadł܂AāACł邱Ƃ́AMDL\bh(ftHg)łB"""
"""""","""Use Kononenko's MDL criterion. If set to false""","""KononenkoMDL]gpĂB Ă̂ɃZbgĂȂ"""
"""""",""" uses the Fayyad & Irani criterion.""",""" prFayyadƃC̕]B"""
"""""","""Uses a more efficient split point encoding.""","""Iȕ|CgR[hgp܂B"""
"""""","""Binary attributes are left binary, if option '-A' is not given.""","""IvV'-a'^ȂȂA2ȋ2î܂܂ɂ܂B"""
"""""","""If the class is numeric, k - 1 new binary attributes are generated ""","""NX͐lAkł--1̐V2ȋ͔Ă܂B"""
"""""","""in the manner described in ""Classification and Regression ""","""Őꂽ@AuuނƕAv"""
"""""","""Trees"" by Breiman et al. (i.e. taking the average class value associated ""","""u؁vAvABreiman (Ȃ킿AςNX]͌ۂ܂B"""
"""""","""with each attribute value into account)""","""AJEgւ̊el)"""
"""""","""\tFor each nominal value a new attribute is created, \nnot only if there are more than 2 values.""","""\͊ezʉitFor܂BV͍쐬āAłꍇɂA\nnot2ȏ̒lłB"""
"""""","""Whether all nominal values are turned into new attributes, not only if there are more than 2.""","""2ȏオPɂ̂ł͂ȂAׂĂ̊zʉiVɕς邩ۂɊ֌WȂB"""
"""""","""Produces a random subsample of a dataset using sampling with replacement.""","""ɂW{ogp邱ƂŃf[^Zbǵׂ̖u-Tvv𐶎Y܂B"""
"""""","""The original dataset must ""","""IWĩf[^Zbg͂Ȃ΂Ȃ܂B"""
"""""","""dataset may be specified. The dataset must have a nominal class ""","""f[^Zbg͎w肳邩܂B f[^Zbgɂ́Aڏ̃NXȂ΂Ȃ܂B"""
"""""","""attribute. If not, use the unsupervised version. The filter can be ""","""ʂƍl܂B łȂ΁Aē󂯂Ȃo[WgpĂB tB^͂ł邱Ƃł܂B"""
"""""","""made to maintain the class distribution in the subsample, or to bias ""","""u-TvvAoCAXɃNXzێ邽߂ɁAĂ܂B"""
"""""","""the class distribution toward a uniform distribution. When used in batch ""","""lzɌNXzB ob`Ɏgp邢"""
"""""","""mode (i.e. in the FilteredClassifier), subsequent batches are NOTE resampled.""","""[h(Ȃ킿AFilteredClassifier)Ǎ̃ob`́u-W{ovłӂłB"""
"""""","""\tBias factor towards uniform class distribution.\n""","""tBias̃NXz\nɌĈ\"""
"""""","""\t0 = distribution in input data -- 1 = uniform distribution.\n""","""̓f[^ɂ\t0=z--1=̈lz\n"""
"""""","""\t(default 0)""","""\t(ftHg0)"""
"""""","""Whether to use bias towards a uniform class. A value of 0 leaves the class ""","""̃NXɌăoCAXgp܂? 0̒l̓NX܂B"""
"""""","""distribution as-is, a value of 1 ensures the class distribution is ""","""̂܂܂ŁA1̒lNXzmɂ镪z͂łB"""
"""""","""uniform in the output data.""","""o̓f[^ł́AłB"""
"""""","""The subsample size as a percentage of the original set.""","""IWi̊ƂẮu-TvvTCY̓Zbg܂B"""
"""""","""Supervised resample requires nominal class""","""ēꂽu-Tvv͖ڏ̃NXKvƂ܂B"""
"""""","""spread""","""L܂܂B"""
"""""","""Produces a random subsample of a dataset. The original dataset must ""","""f[^Zbǵׂ̖u-Tvv𐶎Y܂B IWĩf[^Zbg͂Ȃ΂Ȃ܂B"""
"""""","""fit entirely in memory. This filter allows you to specify the maximum ""","""Sɂ܂͂ߍłB ̃tB^ŁAȂ͍őw肵܂B"""
"""""","""""spread"" between the rarest and most common class. For example, you may ""","""ł܂ōłʓIȃNX̊Ԃ́uuL܂ĂvBv Ⴆ΁AȂ͂邱Ƃł܂B"""
"""""","""specify that there be at most a 2:1 difference in class frequencies. ""","""X2:1NXpẍႢłȂ炻łw肵ĂB"""
"""""","""When used in batch mode, subsequent batches are NOT resampled.""","""ob`E[hŎgpꍇǍ̃ob`́u-W{ovł͂܂B"""
"""""","""Wether instance weights will be adjusted to maintain total weight per ""","""Yȑd͂邽߂ɑSdʂێ悤ɒĂԂŖ]ł܂B"""
"""""","""class.""","""NXB"""
"""""","""\tThe maximum class distribution spread.\n""","""\tThe̍ő̃NXzy\n"""
"""""","""\t0 = no maximum spread, 1 = uniform distribution, 10 = allow at most\n""","""ő\t0=yȂA1=̈lzA10=\nXe܂B"""
"""""","""\ta 10:1 ratio between the classes (default 0)""","""\AoCoCANX̊Ԃ10:1̔䗦(ftHg0)"""
"""""","""\tAdjust weights so that total weight per class is maintained.\n""","""tAdjust1NX̑Sdʂ. \nłƎ咣悤ɏd݂\"""
"""""","""\tIndividual instance weighting is not preserved. (default no\n""","""\tIndividualCX^X̏d͕ۑ܂B (ftHgA\܂nB"""
"""""","""\tweights adjustment""","""\tweights"""
"""""","""\tThe maximum count for any class value (default 0 = unlimited).\n""","""\tTheő͂ǂȊKl̂߂ɂ. \n𐔂܂(0=ȏԂŁAftHgƂ܂)B"""
"""""","""-X <num>""","""-X <num>"""
"""""","""The maximum class distribution spread. ""","""ő̃NXz͍L܂܂B"""
"""""","""(0 = no maximum spread, 1 = uniform distribution, 10 = allow at most a ""","""(ő0=yȂA1=̈lzA10=aXe܂B"""
"""""","""10:1 ratio between the classes).""","""NX̊Ԃ10:1̔䗦)"""
"""""","""The maximum count for any class value (0 = unlimited).""","""ǂȊKl(0=)̂߂̍ő̃JEgB"""
"""""","""Sets the random number seed for subsampling.""","""u-W{ovł邽߂̗qݒ肵܂B"""
"""""","""The class attribute must be nominal.""","""NX͖ڏłɈႢ܂B"""
"""""","""SpreadSubsample: *warning* none of the classes have any values in them.""","""SpreadSubsample: NX̂ɏ̒lĂȂƌx܂B"""
"""""",""" Count:""",""" :"""
"""""",""" Total:""",""" v:"""
"""""",""" Avg:""",""" :"""
"""""",""" NewCount:""",""" VKJEg:"""
"""""",""" NewAvg:""",""" VK:"""
"""""","""This filter takes a dataset and outputs a specified fold for cross validation. If you do not want the folds to be stratified use the unsupervised version.""","""̃tB^́AĂ鍇@̂߂Ƀf[^ZbgāAw肳ꂽ܂ڂo͂܂B ܂ڂwɂė~ȂȂAē󂯂Ȃo[WgpĂB"""
"""""","""\tSpecify list of columns to translate in time. First and\n""","""\́Aԓɖ|󂷂邽߂ɃR̃XgtSpecify܂B 1Ԗڂ\n"""
"""""","""\tlast are valid indexes. (default none)""","""\tlast͗LȃCfbNXłB (ȂɂɁAftHgƂ܂)"""
"""""","""\tInvert matching sense (i.e. calculate for all non-specified columns)""","""tInvert}b`O\(Ȃ킿AׂĂ̓LȊÕR\܂)"""
"""""","""\tThe number of instances forward to translate values\n""","""tTheԍ|󂷂邽߂ɐi߂\\n]܂B"""
"""""","""\tbetween. A negative number indicates taking values from\n""","""\tbetweenB \nl܂B"""
"""""","""\ta past instance. (default -1)""","""\t (ftHg -1)"""
"""""","""-I <num>""","""-h <num>"""
"""""","""\tFor instances at the beginning or end of the dataset where\n""","""\tForf[^Zbg̎n߂Iłǂ؂邩A\n"""
"""""","""\tthe translated values are not known, use missing values\n""","""\tthe̖|󂳂ꂽl͒mĂȂāAgp͌l\nłB"""
"""""","""\t(default is to remove those instances).""","""\t(ftHg̗͂菜Ƃł)B"""
"""""","""For instances at the beginning or end of the dataset where the translated ""","""f[^Zbg̎n߂Iłǂ؂邩A|"""
"""""","""values are not known, use missing values (default is to remove those ""","""lmĂȂāAgplłA(ftHg͂菜ƂłB"""
"""""","""instances)""","""CX^X)"""
"""""","""The number of instances forward/backward to merge values between. ""","""l邽߂ɂ͑ÓA܂́A̗̐B"""
"""""","""A negative number indicates taking values from a past instance.""","""͉ߋ̃CX^Xl܂B"""
"""""","""Invert matching sense. ie calculate for all non-specified columns.""","""Ă銴otɂĂBieׂ͂Ă̓LȊÕR\܂B"""
"""""","""An instance filter that adds a new attribute to the dataset.""","""Vf[^ZbgɒǉCX^XtB^B"""
"""""",""" The new attribute will contain all missing values.""",""" Vׂ͂Ă̌l܂ނł傤B"""
"""""","""\tSpecify where to insert the column. First and last\n""","""\́ARwނ߂ɂǂtSpecify邩B 1ԖڂƍŌ\n"""
"""""","""\tare valid indexes.(default last)""","""\͗LȃCfbNXɕ܂v܂B(ŌɃftHgƂ܂)"""
"""""","""-C <index>""","""-C <ԍ>"""
"""""","""\tCreate nominal attribute with given labels\n""","""\t^̃xŖ`쐬\n"""
"""""","""\t(default numeric attribute)""","""\t (ftHg̐l)"""
"""""","""-L <label1,label2,...>""","""-L <label1,label2,...>"""
"""""","""\tName of the new attribute.\n""","""\tVK̖O\n"""
"""""","""\t(default = 'Unnamed')""","""\t (ftHg='Unnamed')"""
"""""","""Unknown attribute type in Add""","""Add̖m̑^Cv"""
"""""","""Index out of range""","""͈͂AĂB"""
"""""","""Set the new attribute's name.""","""V̖Oݒ肵ĂB"""
"""""","""unnamed""",""""""
"""""","""The position (starting from 1) where the attribute will be inserted ""","""}ʒu(1n߂܂)"""
"""""","""(first and last are valid indices).""","""(ŏɂƍŌɁALȃCfbNXXg܂)."""
"""""","""The list of value labels (nominal attribute creation only). ""","""l̃x(ڏ̑쐬p)̃XgB"""
"""""",""" The list must be comma-separated, eg: ""red,green,blue"".""",""" XǵAR}ɂĐ؂藣āAegłɈႢ܂: uuԂAΐFŁAvvB"""
"""""",""" If this is empty, the created attribute will be numeric.""",""" ꂪłȂA쐬ꂽ͐lɂȂł傤B"""
"""""","""Invalid label list at ""","""xLڂal"""
"""""","""\tFull class name of clusterer to use, followed\n""","""gpclusterer\tFullNXAĂ\n"""
"""""","""\teg: ""weka.clusterers.SimpleKMeans -N 3""""","""\2Nڂ̗r: uuweka.clusterers.SimpleKMeans-NA3C`vAv"""
"""""","""-W <clusterer specification>""","""-W<clustererdl>"""
"""""","""\tThe range of attributes the clusterer should ignore.\n""","""clustererׂł鑮\tThe͈͂. \n𖳎܂B"""
"""""","""Invalid clusterer specification string""","""clustererdlXgO"""
"""""","""A filter that adds a new nominal attribute representing the cluster ""","""NX^\Vڏ̑tB^"""
"""""","""assigned to each instance by the specified clustering algorithm.""","""w肳ꂽNX^OASYŊeCX^XɊ蓖Ă܂B"""
"""""","""The clusterer to assign clusters with.""","""NX^蓖Ă邽߂ɁAclustererłB"""
"""""","""a1^2""",""""""
"""""","""lbcesfhrtn""",""""""
"""""","""An instance filter that creates a new attribute by applying a ""","""aKp邱ƂɂĐV쐬CX^XtB^"""
"""""","""mathematical expression to existing attributes. The expression ""","""̑ւ̐B """
"""""","""can contain attribute references and numeric constants. Supported ""","""QƂƐl萔܂ނƂł܂B T|[g܂B"""
"""""","""opperators are :  +, -, *, /, ^, log, abs, cos, exp, sqrt, ""","""opperators͈ȉ̒ʂłB +A-*/^OAcosł镠؂sqrtexp܂B"""
"""""","""floor, ceil, rint, tan, sin, (, ). Attributes are specified ""","""AceilArintĂāA߂ƂĂA() ͎w肳܂B"""
"""""","""by prefixing with 'a', eg. a7 is attribute number 7 (starting from 1).""","""'a'őOɒuƂɂāAႦ΁Aa7͑No.7ł(1n߂)B"""
"""""",""" Example expression : a1^2*a5/log(a7*4.0).""",""" ̎: a1^2*a5/O(a7*4.0)B"""
"""""","""Trouble parsing numeric constant""","""l萔𕪐͂邱ƂɂJ"""
"""""","""log""","""O"""
"""""","""cos""",""""""
"""""","""exp""",""""""
"""""","""sqrt""",""""""
"""""","""floor""",""""""
"""""","""ceil""",""""""
"""""","""rint""",""""""
"""""","""sin""",""""""
"""""","""Mis-matched parenthesis!""","""gł}!"""
"""""","""Unknown object in postfix vector!""","""|XgtBbNXxNgɂ関m̃IuWFNg!"""
"""""","""Problem applying function""","""@\Kp邱Ƃɂ"""
"""""","""Unrecognized operator:""","""FĂȂIy[^:"""
"""""","""\tSpecify the expression to apply. Eg a1^2*a5/log(a7*4.0).""","""\́AKp邽߂ɎtSpecify܂B Eg a1^2*a5/O(a7*4.0)B"""
"""""","""\n\tSupported opperators: ,+, -, *, /, ^, log, abs, cos, ""","""\n\tSupported opperators: +A-*/^OA؂cos܂B"""
"""""","""\n\texp, sqrt, floor, ceil, rint, tan, sin, (, )""","""\n\texpAsqrtAAceilArint͓ĂāA߂ƂĂB(, )"""
"""""","""-E <expression>""","""-E<\>"""
"""""","""\tSpecify the name for the new attribute. (default is the ""","""\͐V̂߂ɖOtSpecify܂B (ftHg͂łB"""
"""""","""expression provided with -E)""","""-E񋟂ꂽ)"""
"""""","""-N <name>""","""-N<܂>"""
"""""","""\tDebug. Names attribute with the postfix parse of the ""","""\tDebugB |XgtBbNX閼O͕͂܂B"""
"""""","""expression.""","""B"""
"""""","""Must specify an expression with the -E option""","""K{-EIvVŎw肵܂B"""
"""""","""Set the name of the new attribute.""","""V̖Oݒ肵ĂB"""
"""""","""Set debug mode. If true then the new attribute will be named with ""","""fobO[hݒ肵ĂB {łȂAV͂邽߂ɖOtŖ]ł܂B"""
"""""","""the postfix parse of the supplied expression.""","""|XgtBbNX͋ꂽ𕪐͂܂B"""
"""""","""Set the math expression to apply. Eg. a1^2*a5/log(a7*4.0)""","""wɓKp悤ɐݒ肵ĂB Ⴆ΁Aa1^2*a5/O(a7*4.0)"""
"""""","""expression""",""""""
"""""","""An instance filter that changes a percentage of a given""","""R̂Ƃ̊ςCX^XtB^"""
"""""",""" attributes values. The attribute must be nominal.""",""" lB ͖ڏłɈႢ܂B"""
"""""",""" Missing value can be treated as value itself.""",""" l̂ƂČlƂł܂B"""
"""""","""\tIndex of the attribute to be changed \n""","""ςꂽ\nł鑮\tIndex"""
"""""","""\t(default last attribute)""","""\t(ŏIʂƍlftHg)"""
"""""","""\tTreat missing values as an extra value \n""","""GLXgƂĒl𓦂\tTreat\n]܂B"""
"""""","""\tSpecify the percentage of noise introduced \n""","""\͎Gꂽ\n̊tSpecify܂B"""
"""""","""\tto the data (default 10)""","""\tto̓f[^łB(ftHg10)"""
"""""","""-P <num>""","""-P@<num>"""
"""""","""Flag to set if missing values are used.""","""Zbgɂ́AlgpĂȂAołB"""
"""""","""Random number seed.""",""""""
"""""","""Percentage of introduced noise to data.""","""ꂽG΃f[^̊B"""
"""""","""Index of the attribute that is to changed.""","""ꂪ鑮̃CfbNX͕ω܂B"""
"""""","""Chosen attribute is numeric.""","""I΂ꂽ͐lł"""
"""""","""Adding noise is not possible:""","""mCŶ͉\ł͂܂:"""
"""""","""Chosen attribute has less than two values.""","""I΂ꂽɁA2̑lł"""
"""""","""Changes the format used by a date attribute.""","""`t̑ŎgpωB"""
"""""","""Chosen attribute not date.""","""Iꂽ͓t`ł͂܂"""
"""""","""Output date format couldn't parse its own output!!""","""o͓ť`͂ꎩg̏o͂𕪐͂邱Ƃł܂ł!"""
"""""","""\tSets the output date format string (default corresponds to ISO-8601).""","""o͂̋L(ftHgISO-8601ɑΉĂ)ƃf[g\tSetsB"""
"""""","""attribute must be of type date (""first"" and ""last"" are valid values)""","""̓^Cvt̂̂łɈႢ܂B(uuŏɁvvƁuuŌvv̂ƂɁALl܂)"""
"""""","""The date format to change to. This should be a ""","""ωť`B ałׂłB"""
"""""","""format understood by Java's SimpleDateFormat class.""","""`JavaSimpleDateFormat̃NXŕ܂B"""
"""""","""pCluster_""",""""""
"""""","""_clusterMembership""",""""""
"""""","""\tFull name of clusterer to use (required).\n""","""tFullgp(Kvł)\nւclusterer\"""
"""""","""\teg: weka.clusterers.EM""","""\2Nڂ̗r: weka.clusterers.EM"""
"""""","""-W <clusterer name>""","""-W<clusterer>"""
"""""","""\tThe range of attributes the clusterer should ignore.""","""clustererׂł鑮\tThé͈B"""
"""""","""\n\t(the class attribute is automatically ignored)""","""\n\t(NX͎Iɖ܂)"""
"""""","""-I <att1,att2-att4,...>""","""-I <att1Aatt2-att4,...>"""
"""""","""A clusterer must be specified""","""clustererw肵Ȃ΂Ȃ܂B"""
"""""","""A filter that uses a density-based clusterer to generate cluster ""","""NX^𔭐̂ɖxx[XclusterergptB^"""
"""""","""membership values; filtered instances are composed of these values ""","""il; tB^[ɂ邱Ƃ̗͂̒lō\܂B"""
"""""","""plus the class attribute (if set in the input data). If a (nominal) ""","""NX(̓f[^ɐݒ肳Ȃ)B ałB(ڏ)łB """
"""""","""class attribute is set, the clusterer is run separately for each ""","""NX͐ݒ肳āAclusterer͕ʁXɂꂼꗧ₳Ă܂B"""
"""""","""class. The class attribute (if set) and any user-specified ""","""NXB NX(ݒ肳Ȃ)Ƃ[UƓ炢w肵܂B"""
"""""","""attributes are ignored during the clustering operation""","""̓NX^O̊ԁA܂B"""
"""""","""The clusterer that will generate membership values for the instances.""","""̂߂ɉil𔭐clustererB"""
"""""","""The range of attributes to be ignored by the clusterer. eg: first-3,5,9-last""","""clusterer. egɂĖׂł鑮͈̔: 1-3A5A9ŏI"""
"""""","""\tSpecify list of columns to copy. First and last are valid\n""","""\́ARs[邽߂ɃR̃XgtSpecify܂B ŏɁAāAŌ̗L\nłB"""
"""""","""\tInvert matching sense (i.e. copy all non-specified columns)""","""tInvert}b`O\(Ȃ킿AׂĂ̓LȊÕRRs[܂)"""
"""""","""Copy of ""","""Rs[܂B"""
"""""","""An instance filter that copies a range of attributes in the""","""ꂪ܂܂ȑRs[CX^XtB^"""
"""""",""" dataset. This is used in conjunction with other filters that""",""" f[^ZbgB gp邱͑Ɋ֘AĂtB^[ɂ܂B"""
"""""",""" overwrite attribute values during the course of their operation --""",""" ނ̑̃R[X̊ԁAl㏑Ă--"""
"""""",""" this filter allows the original attributes to be kept as well""",""" ̃tB^́A܂Ȃۂ̂e܂B"""
"""""",""" as the new attributes.""",""" VƂāB"""
"""""","""Sets copy selected vs unselected action.""","""Rs[I΂ĂȂɑ΂đIZbgB"""
"""""",""" If set to false, only the specified attributes will be copied;""",""" Ă̂ɐݒ肳ƁAw肳ꂽRs[ł傤;"""
"""""",""" If set to true, non-specified attributes will be copied.""",""" {ɐݒ肳ƁALȊȎ̓Rs[ł傤B"""
"""""","""\tSpecifies the (maximum) number of bins to divide numeric""","""\tSpecifies͐l𕪊e(ő)̐łB"""
"""""",""" attributes into.\n""",""" . \nւ̑"""
"""""","""\t(default = 10)""","""\t(ftHg=10)"""
"""""","""-B <num>""","""-B <num>"""
"""""","""\tSpecifies the desired weight of instances per bin for\n""","""\n̗e킠̗̕Kvȏd\tSpecifies"""
"""""","""\tequal-frequency binning. If this is set to a positive\n""","""\tequalpx̎̂Ă邱ƁB ꂪϋɓI\nɐݒ肳Ȃ"""
"""""","""\tnumber then the -B option will be ignored.\n""","""ɁA-B䂾˂\tnumberA\n"""
"""""","""\t(default = -1)""","""\t(ftHg=-1)"""
"""""","""-M <num>""","""-M <num>"""
"""""","""\tUse equal-frequency instead of equal-width discretization.""","""̗Ȗɓpx\tUseB"""
"""""","""\tOptimize number of bins using leave-one-out estimate\n""","""\tOptimizeAgpAue̐\nς܂B"""
"""""","""\tof estimated entropy (for equal-width discretization).\n""","""\tof̓Ggs[(̗Û߂)\nς܂B"""
"""""","""\tIf this is set then the -B option will be ignored.""","""\tIf܂B͐ݒ肳āAɁA-BIvV͖ł傤B"""
"""""","""Can't ignore class when ""","""NX邱ƂłȂA"""
"""""","""changing the number of attributes!""","""̐ς邱!"""
"""""","""Bin number optimization in conjunction ""","""ڑɂe퐔̍œK"""
"""""","""with equal-frequency binning not implemented.""","""px̎̂Ă邱ƂsĂȂԂŁB"""
"""""","""An instance filter that discretizes a range of numeric""","""܂܂ȐldiscretizesCX^XtB^"""
"""""",""" attributes in the dataset into nominal attributes.""",""" ڏ̑ւ̃f[^Zbg̑B"""
"""""",""" Discretization is by simple binning. Skips the class""",""" UȒPȎ̂Ă邱Ƃł܂B NXT{܂B"""
"""""",""" attribute if set.""",""" ݒ肳ȂAʂƍl܂B"""
"""""","""Optimize number of equal-width bins using leave-one-out. Doesn't ""","""1ȂԂœ̗egp̐œKĂB doesn't"""
"""""","""work for equal-frequency binning""","""px̎̂Ăɂ́AĂB"""
"""""","""Make resulting attributes binary.""","""ʂƂċN鑮2iɂĂB"""
"""""","""Sets the desired weight of instances per interval for ""","""1Ԋu̗̕Kvȏdݒ肵܂B"""
"""""","""equal-frequency binning.""","""px̎̂Ă邱ƁB"""
"""""","""If set to true, equal-frequency binning will be used instead of""","""̑ɂ{́AāApx̎̂Ă邱Ƃւ̃ZbggpB"""
"""""",""" equal-width binning.""",""" ̎̂Ă邱ƁB"""
"""""","""Number of bins.""","""e̐B"""
"""""","""'All'""","""'ׂ'"""
"""""","""'(-inf-""","""'(-inf-"""
"""""","""-inf)'""","""-inf)'"""
"""""","""This instance filter takes a range of N numeric attributes and replaces ""","""܂܂NlʂƍlāAւ邱̃CX^XtB^Be"""
"""""","""them with N-1 numeric attributes, the values of which are the difference ""","""N-1̐l邻B̒l͈ႢłB"""
"""""","""between consecutive attribute values from the original instance. eg: \n\n""",""".. IWĩCX^Xeg̘Al̊Ԃ: \n\n"""
"""""","""Original attribute values\n\n""","""IWȋl\n\n"""
"""""","""   0.1, 0.2, 0.3, 0.1, 0.3\n\n""",""" 0.1A0.2A0.3A0.1A0.3~n\n"""
"""""","""New attribute values\n\n""","""Vl\n\n"""
"""""","""   0.1, 0.1, -0.2, 0.2\n\n""",""" 0.1A0.1A-0.2A0.2~n\n"""
"""""","""The range of attributes used is taken in numeric order. That is, a range ""","""ԍŎgp鑮͈̔͂܂B Ȃ킿A͈"""
"""""","""spec of 7-11,3-5 will use the attribute ordering 3,4,5,7,8,9,10,11 for the ""","""ӎu3A4A5A7A8A9A10𖽗߂鑮A11gp7-11A3-5̎dl"""
"""""","""differences, NOT 7,8,9,10,11,3,4,5.""","""7A8A9A10A11A3A4A5ł͂ȂႢB"""
"""""","""\tSpecify list of columns to take the differences between.\n""","""\. \n̈Ⴂ邽߂ɃR̃XgtSpecify܂B"""
"""""","""\tFirst and last are valid indexes.\n""","""\tFirst܂AāAŌɁALȃCfbNX\n܂B"""
"""""","""\t(default none)""","""\t(ȂɂɁAftHgƂ܂)"""
"""""","""Selected attributes must be all numeric""","""Iꂽׂ͂ĐlłȂ΂Ȃ܂B"""
"""""","""Cannot select only one attribute.""","""1̑I邱Ƃł܂B"""
"""""","""Chosen attribute has less ""","""I΂ꂽɁAȉ܂B"""
"""""","""than two values.""","""2̒lB"""
"""""","""\tSets the attribute index.""","""\tSetsB"""
"""""","""\tSpecify the list of values to indicate. First and last are\n""","""\͎l̃XgtSpecify܂B ŏɁAāAŌ\nłB"""
"""""","""\tvalid indexes (default last)""","""\tvalid͍܂B(ŌɃftHgƂ܂)"""
"""""","""-V <index1,index2-index4,...>""","""-V<index1Aindex2-index4>"""
"""""","""\tSet if new boolean attribute nominal.""","""\tSetȁAAV_ZqڏłB"""
"""""","""-N <index>""",""""""
"""""","""A filter that creates a new dataset with a boolean attribute ""","""_ZqŐVf[^Zbg쐬tB^"""
"""""","""replacing a nominal attribute.  In the new dataset, a value of 1 is ""","""ڏ̑ւ܂B Vf[^Zbgł́A1̒lłB"""
"""""","""assigned to an instance that exhibits a particular range of attribute ""","""͈̔͂̑CX^XɊ蓖Ă܂B"""
"""""","""values, a 0 to an instance that doesn't. The boolean attribute is ""","""lAȂ01CX^XB _Zq͂łB"""
"""""","""coded as numeric by default.""","""炢lŁAftHgŃR[h܂B"""
"""""","""Sets which attribute should be replaced by the indicator. This ""","""̑CfBP[^ɎւׂłZbgB """
"""""","""attribute must be nominal.""","""͖ڏłɈႢ܂B"""
"""""","""Specify range of nominal values to act on.""","""ezʉi͈̔͂w肵ĂB"""
"""""",""" This is a comma separated list of attribute indices (numbered from""",""" ꂪCfbNXXg̃R}̐؂藣ꂽXgłA(tԂ܂B"""
"""""",""" 1), with ""first"" and ""last"" valid values. Specify an inclusive""",""" 1), uuŏɁvvƁuuŌvv̗LlŁB wAI"""
"""""","""Determines whether the output indicator attribute is numeric. If ""","""o͏Wlł邩ۂɊ֌WȂA肵܂B if"""
"""""","""this is set to false, the output attribute will be nominal.""","""͌Ă̂ɐݒ肳āAo͖͑ڏɂȂł傤B"""
"""""","""neg_""",""""""
"""""","""pos_""",""""""
"""""","""Merges two values of a nominal attribute into one value.""","""ڏ̑2̒l1̒lɍ܂B"""
"""""","""The second index has to be greater ""","""2Ԗڂ̃CfbNX́A肷΂炵Ȃ΂Ȃ܂B"""
"""""","""than the first.""","""1ԖڂB"""
"""""","""Sets the first value to be merged. ""","""ŏ̒lɍ悤ɐݒ肵܂B"""
"""""","""Sets the second value to be merged. ""","""2Ԗڂ̒lɍ悤ɐݒ肵܂B"""
"""""","""Converts all nominal attributes into binary numeric attributes. An ""","""ׂĂ̖ڏ̑2i̐lɕϊ܂B 1"""
"""""","""attribute with k values is transformed into k binary attributes if ""","""kl鑮koCi[ɕς܂B"""
"""""","""the class is nominal (using the one-attribute-per-value approach). ""","""NX͖ڏł(1lI@1̑gp)B"""
"""""","""Binary attributes are left binary.""","""2ȋ2î܂܂ɂ܂B"""
"""""","""If the class is numeric, you might want to use the supervised version of ""","""NXlłȂAȂ͊ēꂽo[WgpĂ邩܂B"""
"""""","""this filter.""","""̃tB^B"""
"""""","""\tSets if binary attributes are to be coded as nominal ones.""","""\tSets2ȋłȂ疼ڏ̂̂ƂăR[h邱ƂɂȂĂ܂B"""
"""""","""\tSpecifies list of columns to act on. First""","""tSpecifiesLڂeR\B 1Ԗ"""
"""""","""Whether resulting binary attributes will be nominal.""","""Ȃ邩ۂɊ֌WȂA2ȋ͖ڏɂȂł傤B"""
"""""","""Set attribute selection mode. If false, only selected""","""I[hݒ肵ĂB I邾łB"""
"""""",""" (numeric) attributes in the range will be discretized; if""",""" (l)łB ͈͂̑discretizedł傤; if"""
"""""",""" true, only non-selected attributes will be discretized.""",""" {ɁAIꂽdiscretizedł傤B"""
"""""","""Normalizes all numeric values in the given dataset (apart from the ""","""͕ʂƂė^ꂽf[^ZbĝׂĂ̐l𐳏ɂA(B"""
"""""","""class attribute, if set). The resulting values ""","""NXݒ肳Ȃ ʂƂċNl"""
"""""","""are in [0,1] for the data used to compute the normalization intervals. ""","""0A퉻ԊuvẐɎgpf[^̂߂1ɂ́A܂B"""
"""""","""Converts all numeric attributes into binary attributes (apart from ""","""͕ʂƂĂׂĂ̐l2ȋɕϊA(B"""
"""""","""the class attribute, if set): if the value of the numeric attribute is ""","""NXAݒ肳Ȃ: l̒lȂ"""
"""""","""exactly zero, the value of the new attribute will be zero. If the ""","""傤ǃ[AV̒l̓[ɂȂł傤B the"""
"""""","""value of the numeric attribute is missing, the value of the new ""","""l̒l͎蓦V̒lłB"""
"""""","""attribute will be missing. Otherwise, the value of the new ""","""͌ł傤B łȂ΁AV̒l"""
"""""","""attribute will be one. The new attributes will nominal.""","""1ɂȂł傤B V͖ڏŖ]ł܂B"""
"""""","""_binarized""","""_binarized܂B"""
"""""","""Transforms numeric attributes using a given transformation method.""","""^ꂽϊ\bhgp邱ƂŐlς܂B"""
"""""","""abs""",""""""
"""""","""No class has been set.""","""NXݒ肳Ă܂"""
"""""","""No method has been set.""","""\bhݒ肳Ă܂"""
"""""","""\tSpecify list of columns to transform. First and last are\n""","""\́Aό`邽߂ɃR̃XgtSpecify܂B ŏɁAāAŌ\nłB"""
"""""","""\tvalid indexes (default none). Non-numeric columns are \n""","""\tvalid͍܂(ȂɂɃftHgƂĂ)B 񐔒l̃R\nłB"""
"""""","""\tskipped.""","""\tskipped܂B"""
"""""","""\tSets the class containing transformation method.\n""","""\tSets͕ϊ\bh\n܂ރNXłB"""
"""""","""\t(default java.lang.Math)""","""\t(ftHgjava.lang.Math)"""
"""""","""-C <string>""","""-C <>"""
"""""","""\tSets the method. (default abs)""","""\t\bhݒ (ftHgabs)"""
"""""","""-M <string>""","""-M <>"""
"""""","""Name of the class containing the method used for the transformation.""","""ϊɎgp郁\bh܂ރNX̖OB"""
"""""","""Name of the method used for the transformation.""","""ϊɎgp郁\bh̖OB"""
"""""","""Whether to process the inverse of the given attribute ranges.""","""^ꂽ̋t邩ǂyт܂B"""
"""""","""An instance filter that obfuscates all strings in the data""","""f[^ׂ̂ẴXgOfCX^XtB^"""
"""""","""Not converting attribute: ""","""ϊłȂ: """
"""""","""\tSpecifies list of columns to Discretize. First""","""tSpecifiesLڂDiscretizeւ̃R\B 1Ԗ"""
"""""",""" and last are valid indexes.\n""",""" āAŌɁALȃCfbNX\n܂B"""
"""""","""\t(default: first-last)""","""\t(ftHgƂĂ: ŏɍŌ)łB"""
"""""","""-R <col1,col2-col4,...>""","""-R<col1Acol2-col4>"""
"""""","""\tInvert matching sense of column indexes.""","""R̈Ӗɍ\tInvert܂B"""
"""""","""\tOutput binary attributes for discretized attributes.""","""discretized̂߂\tOutput2ȋB"""
"""""","""Discretizes numeric attributes using equal frequency binning,""","""px̎̂Ă邱Ƃgp邱ƂŐlDiscretizes܂B"""
"""""",""" where the number of bins is equal to the square root of the""",""" e̐ƓƂ"""
"""""",""" number of non-missing values.""",""" 񌇑l̐B"""
"""""","""Always true.""","""{łB"""
"""""","""Ignored.""","""ɂB"""
"""""","""Sparse 1""","""܂΂1"""
"""""","""Sparse 2""","""܂΂2"""
"""""","""Gaussian""","""KEX"""
"""""","""\tThe number of dimensions (attributes) the data should be reduced to\n""","""f[^炳ׂł鐡@()\tTheԍA\n"""
"""""","""\t(default 10; exclusive of the class attribute, if it is set).""","""\tA(NXrIȃftHg10ꂪݒ肳Ȃ"""
"""""","""-N <number>""","""-N<>"""
"""""","""\tThe distribution to use for calculating the random matrix.\n""","""ׂɂČvẐɃ}gNX\ngp\tThez"""
"""""","""\tSparse1 is:\n""","""\tSparse1A: \nłB"""
"""""","""\t  sqrt(3)*{-1 with prob(1/6), 0 with prob(2/3), +1 with prob(1/6)}\n""","""\Aprob(1/6)t sqrt(3)*{-1Aprob(2/3)A+10Aprob(1/6)}\n"""
"""""","""\tSparse2 is:\n""","""\tSparse2A: \nłB"""
"""""","""\t  {-1 with prob(1/2), +1 with prob(1/2)}\n""","""\Aprob(1/2)A+1t{-1Aprob(1/2)}\n"""
"""""","""-D [SPARSE1|SPARSE2|GAUSSIAN]""","""-DSPARSE1| SPARSE2|AKEX"""
"""""","""\tUse Gaussian distribution for calculating the random matrix.""","""ׂ̃}gNXvZ邽߂\tUse GaussianzB"""
"""""","""\tThe percentage of dimensions (attributes) the data should\n""","""f[^ׂł鐡@()\tTheA\n"""
"""""","""\tbe reduced to (exclusive of the class attribute, if it is set). This -N\n""","""tbe\(ꂪNXĐݒ肳Ȃ)B A-AN\n"""
"""""","""\toption is ignored if this option is present or is greater\n""","""\toption͂̃IvV݂Ă邩A肷΂炵\nłȂ疳܂B"""
"""""","""\tthan zero.""","""tthan[\B"""
"""""","""-P <percent>""",""""""
"""""","""\tReplace missing values using the ReplaceMissingValues filter""","""ReplaceMissingValuestB^gp邱ƂŒl𓦂\tReplace"""
"""""","""\tThe random seed for the random number generator used for\n""","""̂߂tTheׂ̖̎q\nɎgp\"""
"""""","""\tcalculating the random matrix (default 42).""","""ׂ̃}gNX(ftHg42)tcalculating\B"""
"""""","""-R <num>""","""-R<num>"""
"""""","""sparse1""",""""""
"""""","""sparse2""",""""""
"""""","""gaussian""","""KEX"""
"""""","""Reduces the dimensionality of the data by projecting""","""ˏo邱ƂɂāAf[^̎܂B"""
"""""",""" it onto a lower dimensional subspace using a random""",""" ́ȀׂԂagp邱ƂŎu-Xy[Xvaɉ낵܂B"""
"""""",""" matrix with columns of unit length (i.e. It will reduce""",""" jbgɊւR}gNXA(Ȃ킿AIt͌ł傤B"""
"""""",""" the number of attributes in the data while preserving""",""" f[^͕̑̐ۑ߂܂B"""
"""""",""" much of its variation like PCA, but at a much less""",""" PCÂ悤ȕωɂ炸́Äȉɂ鑽"""
"""""",""" computational cost).\n""",""" Rs[^̔p) . \n"""
"""""","""It first applies the  NominalToBinary filter to""","""͍ŏɁANominalToBinarytB^Kp܂B"""
"""""",""" convert all attributes to numeric before reducing the""",""" OɁAׂĂ̑𐔒lɕϊĂB"""
"""""",""" dimension. It preserves the class attribute.""",""" @B ̓NXۑ܂B"""
"""""","""The number of dimensions (attributes) the data should""","""f[^ׂł鐡@()̐"""
"""""",""" be reduced to.""",""" ĂB"""
"""""",""" The percentage of dimensions (attributes) the data should""",""" f[^ׂł鐡@()̊"""
"""""",""" be reduced to  (inclusive of the class attribute). This """,""" (NXŕI)ɌĂB """
"""""",""" NumberOfAttributes option is ignored if this option is""",""" ̃IvVȂANumberOfAttributesIvV͖܂B"""
"""""",""" present or is greater than zero.""",""" [񎦂邩A܂͂΂炵łB"""
"""""","""The random seed used by the random""","""ׂɂĎgp閳ׂ̎q"""
"""""",""" number generator used for generating""",""" Ɏgp鐔̃WFl[^"""
"""""",""" the random matrix """,""" ׂ̃}gNX"""
"""""","""The distribution to use for calculating the random matrix.\n""","""ׂɂČvẐɃ}gNX\ngp镪z"""
"""""","""Sparse1 is:\n""","""Sparse1A: \nłB"""
"""""",""" sqrt(3) * { -1 with prob(1/6), \n""",""" prob(1/6)A\nsqrt(3)*{-1"""
"""""","""               0 with prob(2/3),  \n""",""" 0 prob(2/3)A\n"""
"""""","""              +1 with prob(1/6) } \n""",""" +1 prob(1/6) } \n"""
"""""","""Sparse2 is:\n""","""Sparse2A: \nłB"""
"""""",""" { -1 with prob(1/2), \n""",""" prob(1/2){-1A\n"""
"""""","""   +1 with prob(1/2) } """,""" +1 prob(1/2) } """
"""""","""If set the filter uses weka.filters.unsupervised.attribute.ReplaceMissingValues""","""tB^prweka.filters.unsupervised.attribute.ReplaceMissingValuesݒ肵ĂȂ"""
"""""",""" to replace the missing values""",""" lւ邽߂"""
"""""","""No class has been assigned to the instances""","""NX͑SCX^XɊ蓖ĂĂ܂B"""
"""""","""numAtts: """,""""""
"""""","""percent: ""","""p[Zg: """
"""""","""percent*numAtts: ""","""p[Zg*numAtts: """
"""""","""m_k: """,""""""
"""""","""\tSpecify list of columns to delete. First and last are valid\n""","""\͍폜R̃XgtSpecify܂B ŏɁAāAŌ̗L\nłB"""
"""""","""\tindexes. (default none)""","""\tindexesB (ȂɂɁAftHgƂ܂)"""
"""""","""An instance filter that removes a range of""","""ꂪ͈͂菜CX^XtB^"""
"""""",""" attributes from the dataset.""",""" f[^Zbg̑B"""
"""""","""Specify range of attributes to act on.""","""e鑮͈̔͂w肵ĂB"""
"""""",""" This is a comma separated list of attribute indices, with""",""" ͑CfbNXXg̃R}̐؂藣ꂽXgłB"""
"""""",""" ""first"" and ""last"" valid values. Specify an inclusive""",""" uuŏɁvvƁuuŌvv̗LlB wAI"""
"""""",""" range with ""-"". E.g: ""first-3,5,6-10,last"".""",""" uu--vvŁAyłB E.g: uu1-3(5A6-10)͎܂vBv"""
"""""","""Delete nominal attributes""","""`폜"""
"""""","""Delete numeric attributes""","""l폜"""
"""""","""Delete string attributes""","""^폜"""
"""""","""Delete date attributes""","""t^̑폜"""
"""""","""\tAttribute type to delete. Valid options are ""nominal"", ""","""폜\tAttribute^CvB ÓȑÍuuڏvłvB"""
"""""","""""numeric"", ""string"" and ""date"". (default ""string"")""","""uulvvAuuXgOvvAсuutvBv (ftHguuXgOv"""
"""""","""-T <nominal|numeric|string|date>""",""""""
"""""","""\tInvert matching sense (i.e. only keep specified columns)""","""tInvert}b`O\(Ȃ킿Aw肳ꂽRۂł)"""
"""""","""Removes attributes of a given type.""","""^ꂽ^Cv̑菜܂B"""
"""""","""The type of attribute to remove.""","""菜̃^CvB"""
"""""","""Determines whether action is to select or delete.""","""ÁAI邱ƂɂȂĂ邩A܂͍폜邱ƂɂȂĂ܂B"""
"""""",""" If set to true, only the specified attributes will be kept;""",""" {ɐݒ肳ƁAw肳ꂽۂł傤;"""
"""""",""" If set to false, specified attributes will be deleted.""",""" Ă̂ɐݒ肳ƁAw肳ꂽ͍폜ł傤B"""
"""""","""unknown""","""m"""
"""""","""nominal""","""`^"""
"""""","""numeric""","""l^"""
"""""","""string""","""^"""
"""""","""date""","""t^"""
"""""","""\tMaximum variance percentage allowed (default 99)""","""tMaximumω̊e\(ftHg99)"""
"""""","""-M <max variance %>""","""-M<őω%>"""
"""""","""Removes constant attributes, along with nominal attributes that vary too much.""","""قȂ߂閼ڏ̑ɔ̑菜܂B"""
"""""","""Set the threshold for the highest variance allowed before a nominal attribute will be deleted.""","""ڏ̑폜Oɋe钆ōłωɕ~ݒ肵ĂB"""
"""""","""Specifically, if (number_of_distinct_values / total_number_of_values * 100)""","""m(__قȂ_l/v_ԍ_̒l*100̐_)"""
"""""",""" is greater than this value then the attribute will be removed.""",""" Ă傫l͑łB菜ł傤B"""
"""""","""Replaces all missing values for nominal and numeric attributes in a ""","""m~iŐl̑̂߂ałׂĂ̌lւ܂B"""
"""""","""dataset with the modes and means from the training data.""","""g[jOf[^̃[hƎif[^ZbgB"""
"""""","""Standardizes all numeric attributes in the given dataset ""","""^ꂽf[^ZbĝׂĂ̐lW܂B"""
"""""","""to have zero mean and unit variance (apart from the class attribute, if set).""","""[ςƃjbgω(NX͕ʂƂĐݒ肳Ȃ)߂ɁB"""
"""""","""Converts a string attribute (i.e. unspecified number of values) to nominal ""","""XgO(Ȃ킿As̐̒l)𖼖ڏɕϊ܂B"""
"""""","""(i.e. set number of values). You should ensure that all string values that ""","""(Ȃ킿Al̐ݒ肵܂B) Ȃ́AׂẴXgO]̂ۏ؂ׂłB"""
"""""","""will appear are represented in the first batch of the data.""","""ł傤Bf[^̍ŏ̃ob`ł́A\܂B"""
"""""","""Chosen attribute is not of ""","""I΂ꂽ܂B"""
"""""","""type string.""","""XgO^CvĂB"""
"""""","""Sets which attribute to process. This attribute ""","""vZXɂǂ̑ݒ肷邩B ̑"""
"""""","""must be a string attribute (""first"" and ""last"" are valid values)""","""XgOłȂ炻Ȃ΂Ȃ܂B(uuŏɁvvƁuuŌvv̂ƂɁALl܂)"""
"""""","""\tOutput word counts rather than boolean word presence.\n""","""\tOutput͘_ZqPꑶ\nނJEg\܂B"""
"""""","""\tString containing the set of delimiter characters\n""","""f~^LN^\ñZbg܂łāAtString\"""
"""""","""\t(default: "" \\n\\t.,:'\\""()?!"")""","""\t('ftHg:Auu: \\n~\t.A'\\v()?""vA)"""""""
"""""","""-D <delimiter set>""","""-D<f~^̓Zbg܂>"""
"""""","""\tSpecify list of string attributes to convert to words (as weka Range).\n""","""\́AP(Weka RangeƂĂ)\nɕς邽߂ɃXgÕXgtSpecify܂B"""
"""""","""\t(default: select all string attributes)""","""\t(ftHgƂĂ: ׂẴXgOIĂ)"""
"""""","""-R <index1,index2-index4,...>""","""-R<index1Aindex2-index4>"""
"""""","""\tSpecify a prefix for the created attribute names.\n""","""쐬ꂽ. \n𖽖̂ŁA\͐ړtSpecify܂B"""
"""""","""\t(default: """")""","""\t(ftHg:Auuuu)v"""
"""""","""-P <attribute name prefix>""","""-P<Oړ>"""
"""""","""\tSpecify approximate number of word fields to create.\n""","""\. \n쐬邽߂ɊT̒PꕪtSpecify܂B"""
"""""","""\tSurplus words will be discarded..\n""","""tSurplus\\͎̂Ăł傤B\n"""
"""""","""\t(default: 1000)""","""\t(ftHg: 1000)"""
"""""","""-W <number of words to keep>""","""-W<ۂ[h>"""
"""""","""\tTransform the word frequencies into log(1+fij)\n""","""\tTransform̓O(1+fij)\nւ̒PpxłB"""
"""""","""\twhere fij is the frequency of word i in jth ""","""\twhere fijjth̒Pi̕pxłB"""
"""""","""document(instance).\n""","""hLg()\n"""
"""""","""\tTransform each word frequency into:\n""","""\tTransform͂ꂼpx: \nɌ\܂B"""
"""""","""\tfij*log(num of Documents/num of ""","""\tfij*OA(hLg/numnum܂B"""
"""""",""" documents containing word i)\n""",""" Pi܂ރhLg) \n"""
"""""","""\t  where fij if frequency of word i in ""","""\tAǂ̒Pi̕pxłȂfij邩B"""
"""""",""" jth document(instance)""",""" jthhLg(CX^X)"""
"""""","""\tNormalize word frequencies of each ""","""\͂ꂼ̒PpxtNormalize܂B"""
"""""","""document(instance) to average length of ""","""𕽋ςhLg()"""
"""""","""documents.""","""hLgB"""
"""""","""\tOnly form tokens from contiguous ""","""\tOnly͗אڂے`܂B"""
"""""","""alphabetic sequences (The delimiter ""","""At@xbgnA(f~^"""
"""""","""string is ignored if this is set).""","""ꂪݒ肳ȂXgOA)"""
"""""","""\tConvert all tokens to lowercase before ""","""\tConvertׂ͂āAȑOňےłB"""
"""""","""adding to the dictionary.""","""ɉ܂B"""
"""""","""\tIgnore words that are in the stoplist.""","""stoplistɂ\tIgnorePB"""
"""""","""length: """,""": """
"""""","""avgDocLength: """,""""""
"""""",""" setting value """,""" lݒ肵܂B"""
"""""",""" to zero.""",""" [ɍ킹邽߂ɁB"""
"""""","""Converts String attributes into a set of attributes representing ""","""String𑮐\Zbgɕϊ܂B"""
"""""","""word occurrence information from the text contained in the ""","""Ɋ܂܂ꂽeLXg甭\ĂB"""
"""""","""strings. The set of words (attributes) is determined by the first ""","""XgOB P()̃Zbg1܂łɌ肵Ă܂B"""
"""""","""batch filtered (typically training data).""","""tB^[ɂꂽob`(ʏg[jOf[^)B"""
"""""","""Output word counts rather than boolean 0 or 1""","""_Zqނo͌̌v01"""
"""""","""(indicating presence or absence of a word).""","""(P݂̑@܂)."""
"""""","""Set of delimiter characters to use in tokenizing ""","""tokenizingɎgpf~^LN^̃Zbg"""
"""""","""(default: "" \\n\\t.,:'\\""()?!""). ""","""('ftHg:Auu: \\n~\t.A'\\v()?""vA)"""""""
"""""","""This option is ignored if onlyAlphabeticTokens option is set to""","""onlyAlphabeticTokensIvVݒ肳ȂÃIvV͖܂B"""
"""""",""" true.""",""" {B"""
"""""","""Prefix for the created attribute names. ""","""쐬ꂽɂ́AOOɒuĂB"""
"""""","""(default: """")""","""(ftHg:Auuuu)v"""
"""""","""The number of words (per class if there is a class attribute ""","""[hA(NXɏ]āAa΁A𕪗ނĂB"""
"""""","""assigned) to attempt to keep.""","""蓖āA)A݂ɂ́AۂĂB"""
"""""","""Sets whether if the word frequencies should be transformed into:\n ""","""pxPłȂ: \nɕςׂł邩ۂɊ֌WȂAZbg܂B"""
"""""","""   log(1+fij) \n""",""" O(1+fij)\n"""
"""""","""       where fij is the frequency of word i in document (instance) j.""",""" fijhLg(CX^X)j̒Pi̕pxłƂB"""
"""""","""Sets whether if the word frequencies in a document should be ""","""hLg̕pxPłȂZbgׂł邩ۂɊ֌WȂAZbg܂B"""
"""""","""transformed into: \n""","""ϐ: \n"""
"""""","""   fij*log(num of Docs/num of Docs with word i) \n""",""" fij*O(PiDocsDocs/numnum)\n"""
"""""","""      where fij is the frequency of word i in document (instance) j.""",""" fijhLg(CX^X)j̒Pi̕pxłƂB"""
"""""","""Sets whether if the word frequencies for a document (instance) ""","""ZbgAhLĝ߂̒PpxłB(CX^X) """
"""""","""should be normalized or not.""","""ɂׂłB"""
"""""","""Sets whether if the word tokens are to be formed only from ""","""ےPłȂ`邱ƂɂȂĂ邩ۂɊ֌WȂAZbgAB"""
"""""","""contiguous alphabetic sequences (The delimiter string is ""","""אڂ̃At@xbgnA(f~^XgO͂łB"""
"""""","""ignored if this option is set to true).""","""̃IvV{ɐݒ肳Ȃ疳A)"""
"""""","""If set then all the word tokens are converted to lower case ""","""ݒ肳ȂAׂĂ̒PےAP[X낷߂ɕϊ܂B"""
"""""","""before being added to the dictionary.""","""ɒǉOɁB"""
"""""","""Ignores all the words that are on the stoplist, if set to true.""","""{ɐݒ肳Ȃstoplistɂ邷ׂĂ̒P𖳎܂B"""
"""""","""Selected Range: ""","""Iꂽ͈: """
"""""","""Creating dictionary""","""쐬܂B"""
"""""","""words""","""P"""
"""""","""Warning: A word should definitely be in the ""","""x: PꂪmɂׂłB"""
"""""","""dictionary.Please check the code""","""dictionary.Please̓R[h`FbN܂B"""
"""""","""\nCreating word index...""","""\nCreatingPCfbNXc"""
"""""",""" for class id=""",""" NXCh=̂߂"""
"""""","""done: """,""": """
"""""",""" words in total.""",""" vŒPB"""
"""""","""Error. Average Doc Length not defined yet.""","""B ܂`ĂȂDoc Length𕽋ςĂB"""
"""""","""Hack to defeat SparseInstance bug""","""SparseInstanceY܂skɃnbNĂB"""
"""""","""Instance 0""","""CX^X0"""
"""""","""num: """,""""""
"""""",""" index.intValue(): """,""""""
"""""",""" docsCounts: """,""""""
"""""","""setting value ""","""lݒ肵܂B"""
"""""",""": setting value """,""": lݒ肵܂B"""
"""""","""Currently looking at ""","""݁A܂B"""
"""""","""no more tokens present""","""݂̂ȏ̏ے܂B"""
"""""","""found token >""",""""""
"""""","""< beginpos: ""","""<beginpos:"""
"""""",""" endpos: """,""""""
"""""",""" str.length: """,""""""
"""""",""" str[beginpos]: """,""" str beginpos: """
"""""","""Swaps two values of a nominal attribute.""","""ڏ̑2̒l܂B"""
"""""","""Chosen attribute not nominal.""","""ڏłȂIт܂B"""
"""""","""Chosen attribute has less than ""","""I΂ꂽɁAȉ܂B"""
"""""","""two values.""","""2̒lB"""
"""""","""\tSets the attribute index (default last).""","""(ŌɃftHgƂ܂)\tSetsB"""
"""""","""-C <col>""","""-C<>"""
"""""","""\tSets the first value's index (default first).""","""l̍ŏ̂̂(ŏɁAftHgƂ܂)\tSetsB"""
"""""","""-F <value index>""","""-F<lw>"""
"""""","""\tSets the second value's index (default last).""","""l2Ԗڂ̂̂(ŌɃftHgƂ܂)\tSetsB"""
"""""","""-S <value index>""","""-S<lw>"""
"""""","""Sets which attribute to process. This ""","""vZXɂǂ̑ݒ肷邩B """
"""""","""attribute must be nominal (""first"" and ""last"" are valid values)""","""͖ڏłɈႢ܂B(uuŏɁvvƁuuŌvv̂ƂɁALl܂)"""
"""""","""The index of the first value.""","""ŏ̉l̃CfbNXB"""
"""""","""The index of the second value.""","""2Ԗڂ̉l̃CfbNXB"""
"""""","""(""first"" and ""last"" are valid values)""","""(uuŏɁvvƁuuŌvv̂ƂɁALl܂)"""
"""""","""replaces attribute values in the current instance with the difference ""","""݂̃CX^Xɂ鑮lႢɎւ܂B"""
"""""","""between the current value and the equivalent attribute attribute value ""","""slƓȑl̊Ԃ"""
"""""","""of some previous (or future) instance. For instances where the time-shifted ""","""炩̑ÓAāA()̃CX^XɂāB ǂ؂邩AԂɂĈڍsɂ"""
"""""","""value is unknown either the instance may be dropped, or missing values ""","""l͗Ƃ邩A܂͒l𓦂āAႪ邩ȂmłB"""
"""""","""used.""","""gpɂB"""
"""""","""Time delta attributes must be numeric!""","""Ԃ̃f^͐lłɈႢ܂!"""
"""""","""An instance filter that assumes instances form time-series data and ""","""ăCX^XtH[n񂪃f[^łƉ肷CX^XtB^B"""
"""""","""replaces attribute values in the current instance with the equivalent ""","""݂̃CX^Xɂ鑮l𓯓Ɏւ܂B"""
"""""","""attribute attribute values of some previous (or future) instance. For ""","""炩̑ÓAāA()̃CX^X̑lʂƍlĂB for"""
"""""","""instances where the desired value is unknown either the instance may ""","""ڕWlmłႪ"""
"""""",""" be dropped, or missing values used.""",""" gpቺAĂlɂȂĂB"""
"""""","""Only numeric and nominal attributes may be ""","""ĺAāAڏ̗B̑͂łB"""
"""""",""" manipulated in time series.""",""" ԓɁAV[Y𑀂܂B"""
"""""","""destination""","""ړIn"""
"""""","""source""","""\[X"""
"""""","""An instance filter that converts all incoming instances""","""ׂĂ̓ėCX^XϊCX^XtB^"""
"""""",""" into sparse format.""",""" ܂΂Ȍ`ɁB"""
"""""","""An instance filter that normalize instances considering only numeric ""","""llꍇCX^X𐳏ɂCX^XtB^"""
"""""","""attributes and ignoring class index.""","""ƃNX𖳎͍̂܂B"""
"""""","""The LNorm to use.""","""gpւLNormB"""
"""""","""The norm of the instances after normalization.""","""퉻̗̌̕WB"""
"""""","""\tSpecify the norm that each instance must have (default 1.0)""","""\͊eCX^XȂ΂ȂȂWtSpecify܂B(ftHg1.0)"""
"""""","""-N <num>""","""-N<num>"""
"""""","""\tSpecify L-norm to use (default 2.0)""","""gp\tSpecify L-W(ftHg2.0)"""
"""""","""-L <num>""","""-L<num>"""
"""""","""All the attributes must be numeric""","""ׂĂ̑lłɈႢ܂B"""
"""""","""Randomly shuffles the order of instances passed through it. ""","""蓖肵ɁAʂ蔲̒Vbt܂B"""
"""""","""The random number generator is reset with the seed value whenever ""","""킪qlŃZbgA"""
"""""","""a new set of instances is passed in.""","""VZbg̗ł́Aʉ߂܂B"""
"""""","""\tSpecify the random number seed (default 42)""","""\͗qtSpecify܂B(ftHg42)"""
"""""","""Seed for the random number generator.""","""ɂ́AĂB"""
"""""","""\tSpecifies number of folds dataset is split into. \n""","""f[^Zbg܂ڂ\tSpecifiesԍB \n"""
"""""","""\t(default 10)\n""","""\t(ftHg10)\n"""
"""""","""-N <number of folds>""","""-N<܂ڂ̐>"""
"""""","""\tSpecifies which fold is selected. (default 1)\n""","""܂dȂ\tSpecifiesI܂B (ftHg1)\n"""
"""""","""-F <fold>""","""-F<܂dȂ܂>"""
"""""","""\tSpecifies random number seed. (default 0, no randomizing)\n""","""\tSpecifiesqB (ftHg0A_}CYȂ)\n"""
"""""","""-S <seed>""","""-S<܂>"""
"""""","""This filter takes a dataset and outputs a specified fold for cross validation. If you want the folds to be stratified use the supervised version.""","""̃tB^́AĂ鍇@̂߂Ƀf[^ZbgāAw肳ꂽ܂ڂo͂܂B ܂ڂwɂė~ȂAēꂽo[WgpĂB"""
"""""","""The number of folds to split the dataset into.""","""f[^Zbg𕪂܂ڂ̐B"""
"""""","""Number of folds has to be positive or zero.""","""܂ڂ̐́A[łȂ΂Ȃ܂B"""
"""""","""The fold which is selected.""","""I܂ځB"""
"""""","""Fold's index has to be greater than 0.""","""܂ڂ̃CfbNX0ȏłȂ΂Ȃ܂B"""
"""""","""the random number seed for shuffling the dataset. If seed is negative, shuffling will not be performed.""","""f[^ZbgVbt邽߂̗qB qےIłȂAVbt͎sȂł傤B"""
"""""","""Fold has to be smaller or equal to ""","""܂ڂ́A菬A܂͓Ȃ΂Ȃ܂B"""
"""""","""number of folds.""","""܂ڂ̐B"""
"""""","""\tFull class name of classifier to use, followed\n""","""gpNVt@CAAĂ\n\tFullNX"""
"""""","""\tby scheme options. (required)\n""","""\tby̌nIvVB (Kv)łB\n"""
"""""","""\teg: ""weka.classifiers.bayes.NaiveBayes -D""""","""\2Nڂ̗r: uuweka.classifiers.bayes.NaiveBayes-Dvv"""
"""""","""-W <classifier specification>""","""-W<NVt@CAdl>"""
"""""","""\tAttribute on which misclassifications are based.\n""","""\tAttributeǂ̕ތɊÂĂ邩A\n"""
"""""","""\tIf < 0 will use any current set class or default to the last attribute.""","""tIf<0~͍Ō̑ɂǂȌ݂̃ZbgENXftHggpł傤B"""
"""""","""-C <class index>""","""-C<NXCfbNX>"""
"""""","""\tThe number of folds to use for cross-validation cleansing.\n""","""Ă鍇@\nɎgp܂ڂ\tTheԍ"""
"""""","""\t(<2 = no cross-validation - default).""","""\t<Ă2=@܂--ftHg)B"""
"""""","""-F <number of folds>""","""-F<܂ڂ̐>"""
"""""","""\tThreshold for the max error when predicting numeric class.\n""","""lNX\n\Ƃ̍ő̂߂\tThreshold"""
"""""","""\t(Value should be >= 0, default = 0.1).""","""\t(l>=0AftHg=0.1łׂł)B"""
"""""","""-T <threshold>""","""-T<~>"""
"""""","""\tThe maximum number of cleansing iterations to perform.\n""",""".. \ns\tTheő吔̏򉻌JԂ"""
"""""","""\t(<1 = until fully cleansed - default)""","""\t(Sɐ܂ł<1=--ftHg)"""
"""""","""\tInvert the match so that correctly classified instances are discarded.\n""","""\}b`tInvert̂ŐނꂽႪ̂ĂA\n"""
"""""","""A classifier must be specified""","""NVt@CAw肵Ȃ΂Ȃ܂B"""
"""""",""" with the -W option.""",""" -WIvVŁB"""
"""""","""Invalid classifier specification string""","""̃NVt@CAdlXgO"""
"""""","""A filter that removes instances which are incorrectly classified. Useful for removing outliers.""","""sɕނ菜tB^B AEgCA[菜Ƃ̖ɗ܂B"""
"""""","""The classifier upon which to base the misclassifications.""","""ތbÂNVt@CAB"""
"""""","""Index of the class upon which to base the misclassifications. ""","""ތbÂNX̃CfbNXB"""
"""""","""If < 0 will use any current set class or default to the last attribute.""","""<0ǂȓdgpȂAŌ̑ɃNXftHgݒ肵ĂB"""
"""""","""The number of cross-validation folds to use. If < 2 then no cross-validation will be performed.""","""Ă鍇@͎̐gpɐ܂dȂ܂B <2łȂAǂȌĂ鍇@sȂł傤B"""
"""""","""Threshold for the max allowable error when predicting a numeric class. Should be >= 0.""","""lNX\Ƃ̍ő勖e덷̂߂̕~B >=0łׂłB"""
"""""","""The maximum number of iterations to perform. < 1 means filter will go until fully cleansed.""","""sJԂ̍ő吔B <1́AtB^Sɐ܂œ̂Ӗ܂B"""
"""""","""Whether or not to invert the selection. If true, correctly classified instances will be discarded.""","""Itɂ܂? {́AāAނꂽႪ̂ĂȂB"""
"""""","""\tSpecifies percentage of instances to select. (default 50)\n""","""ICX^X\tSpecifiesB (ftHg50)\n"""
"""""","""-P <percentage>""","""-P<>"""
"""""","""A filter that removes a given percentage of a dataset.""","""f[^Zbg̗^ꂽ菜tB^B"""
"""""","""The percentage of the data to select.""","""If[^̊B"""
"""""","""Percentage must be between 0 and 100.""","""0100̊ԂɈႢ܂B"""
"""""","""\tSpecifies list of instances to select. First and last\n""","""tSpecifiesLڂI\B 1ԖڂƍŌ\n"""
"""""","""\tare valid indexes. (required)\n""","""\͗LȃCfbNXɕ܂v܂B (Kv)łB\n"""
"""""","""-R <inst1,inst2-inst4,...>""","""-R<inst1Ainst2-inst4>"""
"""""","""\tSpecifies if inverse of selection is to be output.\n""","""o͑IŋtłȂA\tSpecifies\nł邱ƂɂȂĂB"""
"""""","""A filter that removes a given range of instances of a dataset.""","""f[^Zbg̗̗^ꂽ͈͂菜tB^B"""
"""""","""The range of instances to select. First and last are valid indexes.""","""I͈̔́B ܂ŏɂƍŌɁALȃCfbNX܂B"""
"""""","""Whether to invert the selection.""","""Itɂ܂?"""
"""""","""Filters instances according to the value of an attribute.""","""̒lɏ]āACX^XtB^[ɂ܂B"""
"""""","""\tChoose attribute to be used for selection.""","""tChooseIɎgp邽߂Ɍʂƍl\B"""
"""""","""-C <num>""","""-C<num>"""
"""""","""\tNumeric value to be used for selection on numeric\n""","""tNumericIɐl\nŎgp邽߂ɕ]\"""
"""""","""\tattribute.\n""","""\. \ntattribute܂B"""
"""""","""\tInstances with values smaller than given value will\n""","""^ꂽll\tInstances\n"""
"""""","""\tbe selected. (default 0)""","""tbeI\B (ftHg0)"""
"""""","""\tRange of label indices to be used for selection on\n""","""I\nŎgpׂł郉xCfbNXXg\tRange"""
"""""","""\tnominal attribute.\n""","""\tnominal\n"""
"""""","""\tFirst and last are valid indexes. (default all values)""","""\tFirstƍŏI͗LȃCfbNXłB (ׂĂ]ftHg)"""
"""""","""-L <index1,index2-index4,...>""","""-L<index1Aindex2-index4>"""
"""""","""\tMissing values count as a match. This setting is\n""","""\tMissingl̓}b`ɂ݂Ȃ܂B ̐ݒ\nłB"""
"""""","""\tindependent of the -V option.\n""","""\tindependent-V. \n䂾˂܂B"""
"""""","""\t(default missing values don't match)""","""\t(lȂftHg)"""
"""""","""\tInvert matching sense.""","""tInvert}b`O\B"""
"""""","""\tWhen selecting on nominal attributes, removes header\n""","""\́Aڏ̑ł̑ItWhenāAwb_[\n菜܂B"""
"""""","""\treferences to excluded values.""","""ꂽlւ\treferencesB"""
"""""","""first-last""","""Ō1Ԗ"""
"""""","""Can only handle numeric ""","""lƂł邾łB"""
"""""","""or nominal attributes.""","""܂́Aڏ̑B"""
"""""","""When selecting on nominal attributes, removes header references to ""","""ڏł̑IʂƍlāAwb_[QƂ菜"""
"""""","""excluded values.""","""l܂B"""
"""""","""Choose attribute to be used for selection (default last).""","""I(ŌɃftHgƂĂ)AIɎgpĂB"""
"""""","""Numeric value to be used for selection on numeric attribute. ""","""IɐlŎgpׂł鐔lB"""
"""""","""Instances with values smaller than given value will be selected.""","""ll^菬͑Ił傤B"""
"""""","""Missing values count as a match. This setting is independent of ""","""l̓}b`ɂ݂Ȃ܂B ݒ̔@ɂ炸邱"""
"""""","""the invertSelection option.""","""invertSelectionIvVB"""
"""""","""Invert matching sense.""","""Ă銴otɂĂB"""
"""""","""Range of label indices to be used for selection on nominal attribute. ""","""Iɖڏ̑Ŏgpׂł郉xCfbNXXg͈̔́B"""
"""""","""First and last are valid indexes.""","""܂ŏɂƍŌɁALȃCfbNX܂B"""
"""""","""Produces a random subsample of a dataset using sampling with""","""W{ogpf[^Zbgáׂu-Tvv𐶎Y܂B"""
"""""","""replacement. The original dataset must ""","""B IWĩf[^Zbg͂Ȃ΂Ȃ܂B"""
"""""","""fit entirely in memory. The number of instances in the generated ""","""Sɂ܂͂ߍłB ̗̐"""
"""""","""dataset may be specified.""","""f[^Zbg͎w肳邩܂B"""
"""""","""\tSpecify the random number seed (default 1)""","""\͗qtSpecify܂B(ftHg1)"""
"""""","""-S <num>""","""-S<num>"""
"""""","""\tThe size of the output dataset, as a percentage of\n""","""\n̊ƂĂ̏o̓f[^Zbg\tTheTCY"""
"""""","""\tthe input dataset (default 100)""","""\tthe̓f[^Zbg͂܂B(ftHg100)"""
"""""","""-Z <num>""","""-Z<num>"""
"""""","""The seed used for random sampling.""","""גo@ɎgpqB"""
"""""","""Size of the subsample as a percentage of the original dataset.""","""IWĩf[^Zbg̊ƂẮu-TvṽTCYB"""
"""""","""An instance filter that converts all incoming sparse instances""","""ׂĂ̓ė܂΂ȃCX^XϊCX^XtB^"""
"""""",""" into non-sparse format.""",""" ܂΂Ȍ`ɁB"""
"""""","""Get mean...""","""ӒnɂȂĂc"""
"""""","""Set all values to...""","""ׂĂ̒lɂ悤ɐݒ肵ĂB"""
"""""","""Set missing values to...""","""lɂ悤ɐݒ肵ĂB"""
"""""","""Replace values with...""","""lւ܂B"""
"""""","""Delete attributes...""","""폜Ăc"""
"""""","""Delete selected instance""","""IꂽCX^X폜ĂB"""
"""""","""Delete ALL selected instances""","""ׂĂ̑Iꂽ폜ĂB"""
"""""","""Right click for context menu""","""ReLXgj[ɂ́AENbNĂB"""
"""""","""<html><b>Sort view:</b> left click = ascending / Shift + left click = descending<br><b>Menu:</b> right click</html>""","""<html><b>ގ_: </b>NbN=㏸/Vtg+NbN=(<Br>)(<b>)j[: </b>ENbNĂB</html>"""
"""""","""-none-""","""-Ȃ"""
"""""","""Mean for attribute...""","""̂߂ɁAӖ܂B"""
"""""","""Mean for attribute '""","""'̂߂̕'"""
"""""","""Replace missing values...""","""lւĂc"""
"""""","""New value for MISSING values""","""MISSINGl̂߂̐Vl"""
"""""","""Set all values...""","""ׂĂ̒lݒ肵Ăc"""
"""""","""New value for ALL values""","""ׂĂ̒l̂߂̐Vl"""
"""""","""Replace values...""","""lւĂc"""
"""""","""Old value""","""Âl"""
"""""","""New value""","""Vl"""
"""""","""Do you really want to delete the attribute '""","""'Ȃ͖{ɑ폜Ă܂'"""
"""""","""Confirm...""","""mF܂B"""
"""""","""Do you really want to delete these ""","""Ȃ͖{ɂ폜Ă܂B"""
"""""",""" attributes?""",""" ?"""
"""""","""Rename attribute...""","""Ăc"""
"""""","""Enter new Attribute name""","""VAttributeĂB"""
"""""","""Enter the string to search for""","""{߂XgOɓĂB"""
"""""","""Question...""","""₵Ăc"""
"""""","""Do you really want to copy the whole table?""","""Ȃ͖{ɑŜ̃e[uRs[ł?"""
"""""","""missing""","""܂B"""
"""""","""Error loading file...""","""胍[fBOt@Cc"""
"""""","""<html><center>No.<br><font size=""-2"">&nbsp;</font></center></html>""",""""""
"""""","""<html><center>""",""""""
"""""","""<br><font size=""-2"">Date</font>""","""<br><font size=""-2"">t^</font>"""
"""""","""<br><font size=""-2"">Nominal</font>""","""<br><font size=""-2"">`^</font>"""
"""""","""<br><font size=""-2"">String</font>""","""<br><font size=""-2"">^</font>"""
"""""","""<br><font size=""-2"">Numeric</font>""","""<br><font size=""-2"">l^</font>"""
"""""","""arffviewer""",""""""
"""""","""Quit - ""","""f -"""
"""""","""Do you really want to quit?""","""Ȃ͖{ɂ߂ł?"""
"""""","""Loading ""","""[fBO"""
"""""","""Finished!""","""I!"""
"""""","""\nrestarting...""","""\năX^[gc"""
"""""","""ARFF-Viewer""","""ARFF-r[A["""
"""""","""ARFF-Files""","""ARFF-t@C"""
"""""","""CSV-File""","""CSV-t@C"""
"""""","""File""","""t@C"""
"""""","""Close""",""""""
"""""","""Close all""","""Sĕ"""
"""""","""Properties""",""""""
"""""","""Exit""","""o"""
"""""","""Copy""","""Rs["""
"""""","""Search...""","""Tc"""
"""""","""Clear search""","""̃NA"""
"""""","""Rename attribute""",""""""
"""""","""Delete attribute""","""폜"""
"""""","""Delete attributes""","""폜ĂB"""
"""""","""Delete instance""","""CX^X폜"""
"""""","""Delete instances""","""CX^X폜"""
"""""","""Sort data (ascending)""","""f[^̃\[g()"""
"""""","""View""","""_"""
"""""","""Attributes...""","""c"""
"""""","""Values...""","""lc"""
"""""","""Changed""","""ύX܂"""
"""""","""The file is not saved - Do you want to save it?""","""t@C͕ۑ܂--Ȃ͂ۑł?"""
"""""","""nothing selected!""","""łȂIȂ!"""
"""""","""Want to save changes""","""ύXf[^ۑłB"""
"""""","""Filename: ""","""t@C: """
"""""","""Relation name: ""","""֌W: """
"""""","""# of instances: ""","""# ɂ: """
"""""","""# of attributes: ""","""# ɂ: """
"""""","""Class attribute: ""","""NX: """
"""""","""# of class labels: ""","""# NXxɂ: """
"""""","""Save File""","""t@CۑĂB"""
"""""","""Attribute List Panel""","""Xgpl"""
"""""","""Name""","""O"""
"""""","""selected""","""Iꂽ"""
"""""","""All""","""ׂ"""
"""""","""Invert""","""It]"""
"""""","""Selects all attributes""","""ׂĂ̑I"""
"""""","""Unselects all attributes""","""ׂĂ̑I"""
"""""","""Inverts the current attribute selection""","""݂̑It]"""
"""""","""supply the name of an arff file""","""arfft@C̖O񋟂Ă"""
"""""","""Label""","""x"""
"""""","""Count""","""JEg"""
"""""","""Statistic""","""vl"""
"""""","""Value""","""l"""
"""""","""Minimum""","""ŏ"""
"""""","""Maximum""","""ő"""
"""""","""Mean""",""""""
"""""","""StdDev""","""W΍"""
"""""","""Nominal""","""`"""
"""""","""Numeric""","""l"""
"""""","""String""",""""""
"""""","""Date""","""t"""
"""""","""Unknown""","""m"""
"""""","""Attribute Panel""","""pl"""
"""""","""Attribute""",""""""
"""""","""No Class""","""NX܂"""
"""""","""Default""","""ftHg"""
"""""","""No class""","""NX܂"""
"""""","""Class: ""","""NX: """
"""""","""(Nom)""","""(`^)"""
"""""","""attrib: """,""":"""
"""""",""" class: """,""" NX: """
"""""","""histCount: """,""""""
"""""",""" Actual: """,""" : """
"""""",""" stdDev: ""","""W΍:"""
"""""","""intervalWidth: """,""""""
"""""","""Data-Based Choice of Histogram Bin Width""","""qXgOe핝̃f[^x[X̑I"""
"""""","""On optimal and data-based histograms""","""œḰAāAf[^x[X̃qXgOɊւ"""
"""""",""" barRange:""",""""""
"""""",""" histLength:""",""""""
"""""",""" value:""",""" l:"""
"""""",""" min:""",""" ŏ:"""
"""""",""" sumResult:""","""v:"""
"""""",""" divideResult:""",""""""
"""""",""" finalResult:""","""ŏI:"""
"""""","""psi returns: ""","""psi̕Ԃl: """
"""""","""g21 returns: ""","""g21̕Ԃl: """
"""""","""g22 returns: ""","""g22̕Ԃl: """
"""""","""In c before doing the sum we have""","""Ă鍇vOc"""
"""""","""max: ""","""ő: """
"""""",""" min: """,""" ŏ: """
"""""",""" sigma: """,""" VO}: """
"""""","""c returns: ""","""c͖߂܂: """
"""""","""Before calling L we have""","""LƌĂԎĂO"""
"""""","""Max: ""","""ő: """
"""""",""" Min: """,""" ŏ: """
"""""","""k returns: ""","""k͖߂܂: """
"""""","""L returns: ""","""L͖߂܂: """
"""""","""&lt;nominal value&gt; [&lt;nominal value count&gt;]""","""; ltƖڏ̒lgt; lt܂; zʉiJEggt;B"""
"""""","""count &lt;br&gt; [&lt;bars Range&gt;]""","""JEglt; Brgt; lt܂; o[͈͂gt;B"""
"""""","""count &lt;br&gt; (&lt;bar's Range&gt;]""","""JEglt; Brgt; (lt(o[͈̂̔͂gt)"""
"""""","""<html><center><font face=Dialog size=-1>""",""""""
"""""","""centered""","""Sɒu܂B"""
"""""","""Filling x:""","""ςɂȂĂx:"""
"""""",""" width:""",""" :"""
"""""",""" height:""",""" :"""
"""""",""" histBarCount:""",""""""
"""""","""Attribute is neither numeric nor nominal.""","""́AlłȂĂ܂ڏł͂܂B"""
"""""","""Calculating. Please Wait...""","""vZłD҂c"""
"""""","""AttribVisualization""",""""""
"""""","""Usage: java AttributeVisualizationPanel""","""p@: java AttributeVisualizationPanel"""
"""""",""" [arff file] [index of attribute]""",""" arfft@C͑ɍ܂B"""
"""""","""AbstractDataSink""",""""""
"""""","""AbstractDataSource""",""""""
"""""","""AbstractEvaluator""",""""""
"""""","""AbstractTestSetProducer""",""""""
"""""","""AbstractTrainingSetProducer""",""""""
"""""","""AbstractTraingSetProducer""",""""""
"""""","""Plot summary bar charts for incoming data/training/test sets.""","""ėf[^/g[jO/eXgEZbĝ߂ɊTv_OtłB"""
"""""","""gridWidth""","""Obh"""
"""""","""maxPlots""","""ővbg"""
"""""","""AttributeSummarizer""",""""""
"""""","""Show summaries""","""Tv̕\"""
"""""",""" not supported (AttributeSummarizer)""",""" T|[gĂ܂(AttributeSummarizer)"""
"""""","""Usage: AttributeSummarizer <dataset>""","""p@: AttributeSummarizer<f[^Zbg>"""
"""""","""removing connection""","""ڑ"""
"""""","""Select target""","""ڕWI"""
"""""","""Unable to connect beans (BeanConnection)""","""beansƐڑ邱Ƃł܂(BeanConnection)"""
"""""","""Deregistering listener""",""""""
"""""","""Problem retrieving event set descriptor (BeanConnection)""","""CxgZbgLqq邱Ƃɂ(BeanConnection)"""
"""""","""Removing bean""","""Bean菜܂B"""
"""""","""Component is invisible!""","""R|[lg͖ڂɌ܂!"""
"""""","""connector""","""RlN^"""
"""""","""Unrecognised connectorPoint (BeanVisual)""","""FĂȂconnectorPoint(BeanVisual)"""
"""""","""ClassAssigner""",""""""
"""""","""Designate which column is to be considered the class column ""","""NXRłƍlāARɂ͂̂w肵ĂB"""
"""""","""in incoming data.""","""ėf[^ŁB"""
"""""","""Specify the number of the column that contains the class attribute""","""NX܂ރR̐w肵ĂB"""
"""""","""Assigning class column...""","""NXR蓖Ă܂c"""
"""""","""Notifying customizer...""","""customizerɒʒm܂c"""
"""""","""Class column outside range of data ""","""f[^̃NXRO͈̔"""
"""""","""(ClassAssigner)""",""""""
"""""","""classColumn""",""""""
"""""","""ClassAssignerCustomizer""",""""""
"""""","""Choose class attribute""","""NX̑I"""
"""""","""Customizer deregistering with class assigner""","""NX̎wlCustomizer deregistering"""
"""""","""Setting up column selection.........""","""RIZbgAbv܂c"""
"""""",""" is not an incremental classifier (Classifier)""",""" ̃NVt@CAł͂܂B(NVt@CA)"""
"""""","""type of algorithm (Classifier)""","""ASỸ^Cv(NVt@CA)"""
"""""","""Starting handler ""","""n߂̑"""
"""""","""Classifier is currently batch training!""","""݁ANVt@CA̓ob`g[jOł!"""
"""""","""Classifier : setting class index...""","""NVt@CA: ݒ̃NX͍܂c"""
"""""",""" has not been batch """,""" ob`ł͂܂B"""
"""""","""trained; can't process instance events.""","""P܂; CX^XCxg邱Ƃł܂B"""
"""""","""ERROR : instance event's structure is different from """,""": \قȂĂCX^XCxĝ"""
"""""","""the data that ""","""f[^A"""
"""""","""was used to batch train this classifier; can't continue.""","""gpāAob`܂ŁÃNVt@CAPĂƂƂł; Ƃł܂B"""
"""""","""Warning : structure of instance events differ ""","""x: CX^XCxg̍\͈قȂ܂B"""
"""""","""from data used in batch training this ""","""Pob`Ɏgpf[^"""
"""""","""classifier. Resetting classifier...""","""NVt@CAB NVt@CAZbg܂c"""
"""""","""NOTIFYING NEW BATCH""","""Vob`ɒʒm܂B"""
"""""","""Classifier : assuming last ""","""ފwK : Ō̑"""
"""""","""column is the class""","""NXƂ݂Ȃ܂"""
"""""","""Building model...""","""f\zc"""
"""""","""Classifier : building model...""","""ފwK: f\zc"""
"""""","""=== Classifier model ===\n\n""","""=== ފwKf ===\n\n"""
"""""","""Build classifier interrupted!""","""ՂꂽNVt@CAgĂĂ!"""
"""""","""Just before notify classifier listeners""","""ANVt@CAXi[͈ȑOAʒm܂B"""
"""""","""Just after notify classifier listeners""","""傤ǌɃNVt@CAXi[ɒʒmĂB"""
"""""","""Default_""","""ftHg_"""
"""""","""Warning : ""","""x: """
"""""",""" is not an updateable classifier. This """,""" Abvf[g\̓NVt@CAł͂܂? """
"""""","""classifier will only be evaluated on incoming ""","""NVt@CÂ͓Ƃɕ]邾ł傤B"""
"""""","""instance events and not trained on them.""","""̃CxgłĂ̏ŌPĂ܂B"""
"""""","""acceptClassifier""",""""""
"""""","""Update classifier on incoming instance stream""","""ėCX^XXg[ŃNVt@CAAbvf[gĂB"""
"""""","""Train the classifier on ""","""NVt@CA܂B"""
"""""","""each individual incoming streamed instance.""","""ꂼ̌X̓̓CX^X𗬂܂B"""
"""""","""ClassifierPerformanceEvaluator""",""""""
"""""","""Evaluate the performance of batch trained classifiers.""","""ob`̌PꂽNVt@CAɊւт]ĂB"""
"""""","""ClassifierPerformaceEvaluator : ""","""ClassifierPerformaceEvaluator: """
"""""","""=== Evaluation result ===\n\n""","""=== ]===\n\n"""
"""""","""ThresholdCurveInst""",""""""
"""""",""" not supported (ClassifierPerformanceEvaluator)""",""" x܂B(ClassifierPerformanceEvaluator)"""
"""""","""thresholdData""",""""""
"""""","""visualizableError""",""""""
"""""","""ClassValuePicker""",""""""
"""""","""Designate which class value is to be considered the ""positive"" ""","""NXuuϋɓIvvłƍl邱ƂɂȂĂ̂]̂w肵ĂB"""
"""""","""class value (useful for ROC style curves).""","""Kl(ROCX^CJ[u̖ɗ)B"""
"""""","""Is null!!!!!!""","""k͂ł?!"""
"""""","""positive""","""ϋɓI"""
"""""","""No class attribute defined in data set (ClassValuePicker)""","""f[^ZbgŒ`ȂNXS(ClassValuePicker)"""
"""""","""Class attribute must be nominal (ClassValuePicker)""","""NX͖ڏłɈႢ܂B(ClassValuePicker)"""
"""""","""Unable to swap class attibute values (ClassValuePicker)""","""NXattibutel邱Ƃł܂B(ClassValuePicker)"""
"""""","""Notifying data listeners ""","""f[^Xi[ɒʒm܂B"""
"""""","""(ClassValuePicker)""",""""""
"""""","""classValueIndex""",""""""
"""""","""No customization possible at present.""","""݂̂Ƃ\ȉ܂B"""
"""""","""ClassValuePickerCustomizer""",""""""
"""""","""Choose class value""","""NXl̑I"""
"""""","""Customizer deregistering with class value picker""","""KlXCustomizer deregistering"""
"""""","""type of algorithm (Clusterer)""","""ASỸ^Cv(Clusterer)"""
"""""","""Building clusters...""","""NX^쐬c"""
"""""","""Clusterer : building clusters...""","""Clusterer: NX^쐬c"""
"""""","""Set ""","""ݒ """
"""""","""=== Clusterer model ===\n\n""","""=== NX^Oɂ郂f ===\n\n"""
"""""","""\nTraining Fold: ""","""\nTraining܂: """
"""""","""Model: ""","""f: """
"""""","""Build clusterer interrupted!""","""fꂽclusterer𑢂Ă!"""
"""""",""" not supported (Classifier)""",""" x܂B(NVt@CA)"""
"""""","""acceptClusterer""",""""""
"""""","""acceptGraph""",""""""
"""""","""ClustererPerformanceEvaluator""",""""""
"""""","""Evaluate the performance of batch trained clusterers.""","""ob`̌Pꂽclusterers̐\]ĂB"""
"""""","""Evaluating (""","""]A("""
"""""","""ClustererPerformaceEvaluator : ""","""ClustererPerformaceEvaluator: """
"""""","""evaluating (""","""]A("""
"""""","""=== Evaluation result for ""","""=== ]͌ʂɂȂ܂B"""
"""""",""" instances ===\n\n""",""" ===\n\n"""
"""""","""Scheme: ""","""v: """
"""""","""\n\nNo class based evaluation possible. Class attribute has to be nominal.""","""n~\nNoANX͉\ȕ]bÂ܂B NX͖ڏłȂ΂Ȃ܂B"""
"""""","""Done.""","""B"""
"""""","""Evaluation interrupted!""","""]͒f܂!"""
"""""",""" not supported (ClustererPerformanceEvaluator)""",""" x܂B(ClustererPerformanceEvaluator)"""
"""""","""(ClustererPerformanceEvaluator)""",""""""
"""""","""CrossValidationFoldMaker""",""""""
"""""","""Split an incoming data set into cross validation folds. ""","""ėf[^ZbgĂ鍇@܂ڂɕĂB"""
"""""","""Separate train and test sets are produced for each of the k folds.""","""ʁX̗ԂƃeXgEZbg͂ꂼk܂ڂ̂߂ɐY܂B"""
"""""","""CrossValidationFoldMaker : ""","""CrossValidationFoldMaker: """
"""""","""stratifying data""","""f[^wɂ܂B"""
"""""","""Cross validation has been canceled!""","""Ă鍇@͒~܂!"""
"""""","""--Just before notify training set""","""--Ag[jOZbgɈȑOAʒm܂B"""
"""""","""---Just after notify""","""---傤ǌɒʒmĂB"""
"""""","""Cross validation interrupted""","""Ă鍇@͒f܂B"""
"""""","""The number of train and test splits to produce""","""NԂƃeXgҊ̐"""
"""""",""" not supported (CrossValidation)""",""" x܂B(CrossValidation)"""
"""""","""folds""","""܂"""
"""""","""CrossValidationFoldMakerCustomizer""",""""""
"""""","""Visualize incoming data/training/test sets in a 2D scatter plot.""","""2DUzAdɂėf[^/g[jO/eXgEZbgzĂB"""
"""""","""DataVisualizer""",""""""
"""""","""Problem setting up ""","""ZbgAbv邱Ƃɂ"""
"""""","""visualization (DataVisualizer)""","""z(DataVisualizer)"""
"""""",""" not supported (DataVisualizer)""",""" x܂B(DataVisualizer)"""
"""""","""Usage: DataVisualizer <dataset>""","""p@: DataVisualizer<f[^Zbg>"""
"""""","""WARNING : ""","""x: """
"""""",""" is not an incremental filter""",""" ̃tB^ł͂܂B"""
"""""","""type of algorithm (Filter)""","""ASỸ^Cv(tB^[ɂ܂)"""
"""""","""Filter is currently batch processing!""","""tB^͌݁Aob`Ă܂!"""
"""""","""ERROR : """,""": """
"""""","""can't process streamed instances; can't continue""","""ꂽCX^X邱Ƃł܂; Ƃł܂B"""
"""""","""Error in obtaining post-filter structure: Filter.java""","""utB^\肷邱Ƃɂ: Filter.java"""
"""""","""ERROR : filter not ready to output instance""",""": CX^Xo͂鏀łĂȂtB^"""
"""""","""Filtering training data...""","""g[jOf[^tB^[ɂ܂c"""
"""""","""Filter : filtering training data (""","""tB^: g[jOf[^tB^[ɂA("""
"""""","""Filter training set interrupted!""","""tB^g[jOZbg͒f܂!"""
"""""","""Filtering test data...""","""eXgf[^tB^[ɂ܂c"""
"""""","""Filter : filtering test data (""","""tB^: eXgf[^tB^[ɂA("""
"""""","""Filter test set interrupted!""","""tB^eXgEZbg͒f܂!"""
"""""","""Notifying instance listeners ""","""CX^XXi[ɒʒm܂B"""
"""""","""(Filter)""","""(tB^[ɂ܂)"""
"""""",""" not supported (Filter)""",""" T|[g܂B(tB^[ɂ܂)"""
"""""","""acceptTrainingSet""",""""""
"""""","""acceptTestSet""",""""""
"""""","""Here""",""""""
"""""","""dot""","""hbg"""
"""""","""GraphViewer""",""""""
"""""","""Graphically visualize trees or graphs produced by classifiers/clusterers.""","""OtBJɃNVt@CA/clusterersɂčoꂽ؂OtzĂB"""
"""""","""Graph list""","""OtXg"""
"""""","""Graph Viewer""","""Otr[A["""
"""""",""" not supported (GraphViewer)""",""" x܂B(GraphViewer)"""
"""""","""IncrementalClassifierEvaluator""",""""""
"""""","""Evaluate the performance of incrementally trained classifiers.""","""ČPꂽNVt@CAɊւт]ĂB"""
"""""","""NEW BATCH""",""""""
"""""","""RRSE""",""""""
"""""","""Accuracy""",""""""
"""""","""RMSE (prob)""","""RMSE(prob)"""
"""""","""Confidence""","""mMx"""
"""""","""Prediction""","""\"""
"""""","""RMSE""",""""""
"""""","""=== Performance information ===\n\n""","""=== s ===\n\n"""
"""""","""Scheme:   ""","""XL[: """
"""""","""Relation: ""","""֌W: """
"""""","""Results: """,""": """
"""""","""Notifying text listeners """,""""""
"""""","""(ClassifierPerformanceEvaluator)""",""""""
"""""","""chart""",""""""
"""""","""acceptDataPoint""",""""""
"""""","""acceptText""",""""""
"""""","""createSingleton""",""""""
"""""","""Could not read a configuration file for the bean\n""","""Bean\n̍\t@CǂނƂł܂łB"""
"""""","""panel. An example file is included with the Weka distribution.\n""","""plB ̃t@CWekazŊ܂܂ĂA\n"""
"""""","""Could not read a configuration file for the generic objecte editor""","""\t@CWFlbNobjecteGfB^ɓǂݍނƂł܂łB"""
"""""",""". An example file is included with the Weka distribution.\n""",""".. ̃t@CWekazŊ܂܂ĂA\n"""
"""""","""This file should be named ""GenericObjectEditor.props"" and\n""","""̃t@ĆuuGenericObjectEditor.propsvv\nƖׂłB"""
"""""","""KnowledgeFlow configuration files (*""","""KnowledgeFlow\t@CA(*"""
"""""","""KnowledgeFlow layout files (*""","""KnowledgeFlowCAEgt@CA(*"""
"""""","""ScrollBarIncrementLayout""",""""""
"""""","""ScrollBarIncrementComponents""",""""""
"""""","""FlowWidth""",""""""
"""""","""FlowHeight""",""""""
"""""","""PreferredExtension""",""""""
"""""","""UserComponentsInXML""",""""""
"""""","""Weka Knowledge Flow was written by Mark Hall""",""""""
"""""","""Weka Knowledge Flow""","""Weka Knowledge Flow"""
"""""","""(c) 2002-2005 Mark Hall""","""(c) 2002-2005 Mark Hall"""
"""""","""web: http://www.cs.waikato.ac.nz/~ml/""","""EFu: http://www.cs.waikato.ac.nz/~ml/ """
"""""","""Welcome to the Weka Knowledge Flow""","""Weka Knowledge Flowւ悤B"""
"""""","""Knowledge Flow Layout""","""f[^}CjO菇CAEg"""
"""""","""Warning: unable to load ""","""x: [h邱Ƃł܂B"""
"""""","""Save layout""","""CAEg̕ۑ"""
"""""","""Stop all execution""","""ׂĂ̎s~"""
"""""","""Load layout""","""CAEg̃[h"""
"""""","""Display help""","""wv̕\"""
"""""","""Clear the layout""","""CAEgNA"""
"""""","""Failed to instantiate: ""","""Ɏs: """
"""""","""**** Processing user package... ""","""**** [UpbP[Wc"""
"""""","""Would add ""","""ǉ邱Ƃł傤"""
"""""","""Can't find class called: ""","""Ă΂NX͌邱Ƃł܂: """
"""""","""Failed to configure ""","""\邽߂ɁAsĂ܂B"""
"""""",""" with """,""" with"""
"""""","""Failed to instantiate :""","""ȉᎦ邽߂ɁAs܂B"""
"""""","""Problem adding bean to data flow layout""","""f[^t[CAEgBean邱Ƃɂ"""
"""""","""Hold down shift and click to remove""","""VtgĂAāAO߂ɃNbNĂB"""
"""""","""User""","""[U"""
"""""","""User created components""","""[U̍쐬ꂽR|[lg"""
"""""","""Edit""","""ҏW"""
"""""","""Ungroup""","""O[v"""
"""""","""Add to user tab""","""[U^u̒ǉ"""
"""""","""Got bean info""","""beañCtH[V擾"""
"""""","""Got customizer class""","""customizer̃NX擾"""
"""""","""Configure...""","""ݒ..."""
"""""","""Customizer""",""""""
"""""","""Configure: ""","""ݒ: """
"""""","""No customizer class""","""customizer̃NX܂B"""
"""""","""Connections""","""ڑ"""
"""""","""Just before look for other options""","""ȑOÃIvVĂB"""
"""""","""Actions""",""""""
"""""","""Just before showing menu""","""j[O"""
"""""","""Delete Connection""","""ڑ폜"""
"""""","""target count ""","""ڕWJEg"""
"""""","""Group this sub-flow?""","""̃Tut[O[v܂?"""
"""""","""Group Components""","""O[vR|[lg"""
"""""","""Enter a name for this group""","""̃O[v̂߂ɖOĂ"""
"""""","""MyGroup""",""""""
"""""","""Problem reading user components.""","""Ǐ[UR|[lgB"""
"""""","""Saving user components....""","""[UɃR|[lgߖ񂳂܂c"""
"""""","""Unable to create .knowledgeFlow ""","""..knowledgeFlow쐬邱Ƃł܂B"""
"""""","""directory in your HOME.""","""Ȃ̃z[ɂfBNgB"""
"""""","""userComponents""",""""""
"""""","""Unable to save user components""","""[UR|[lgłƕۑ邱Ƃł܂B"""
"""""","""Before sleeping""","""̑O"""
"""""","""NOTIFYING STRUCTURE AVAIL""","""\vɒʒm܂B"""
"""""","""Start...""","""n߂Ăc"""
"""""","""Notifying listeners of instance structure avail. (Loader).""","""CX^X\ɂăXi[ɒʒm͖̂ɗ܂B (וςސl)."""
"""""","""Start loading""","""sJn"""
"""""",""" not supported (Loader)""",""" x܂B(וςސl)"""
"""""",""" Query:       """,""" v: """
"""""",""" Key columns: """,""" L[: """
"""""","""Group""","""O[v"""
"""""","""Visualize performance charts (such as ROC).""","""ptH[}XE`[g(ROCȂǂ)zĂB"""
"""""","""ModelPerformanceChart""",""""""
"""""","""Problem setting up visualization (ModelPerformanceChart)""","""zւ̖ݒ(ModelPerformanceChart)"""
"""""","""Model Performance Chart""","""fptH[}XE`[g"""
"""""",""" not supported (Model Performance Chart)""",""" T|[g܂B(fptH[}XE`[g)"""
"""""","""Usage: ModelPerformanceChart <dataset>""","""p@: ModelPerformanceChart<f[^Zbg>"""
"""""","""PredictionAppender""",""""""
"""""","""Accepts batch or incremental classifier events and ""","""ăob`̃NVt@CAo󂯓B"""
"""""","""produces a new data set with classifier predictions appended.""","""NVt@CA\ǉĂԂŐVf[^Zbgo܂B"""
"""""","""append probabilities rather than labels for discrete class ""","""UIȃNX̂߂ɃxނmǉĂB"""
"""""","""predictions""","""\"""
"""""","""_with predictions""","""_\"""
"""""","""_set_""","""__ݒ肵ĂB"""
"""""","""test""","""eXg"""
"""""","""training""","""g[jO"""
"""""","""Only density based clusterers can append probabilities. Instead cluster will be assigned for each instance.""","""xɊÂĂclusterersmǉ邱Ƃł܂B ɁANX^͊eCX^X̂߂Ɋ蓖Ăł傤B"""
"""""","""prob_""",""""""
"""""","""class_predicted_by: ""","""NX_͈ȉ_\܂B """
"""""","""prob_cluster""","""prob_NX^"""
"""""","""last""","""ŏI"""
"""""","""assigned_cluster: ""","""蓖Ăꂽ_NX^: """
"""""","""incrementalClassifier""",""""""
"""""","""batchClassifier""",""""""
"""""","""batchClusterer""",""""""
"""""","""acceptDataSet""",""""""
"""""","""instance""","""CX^X"""
"""""","""acceptInstance""",""""""
"""""","""appendPredictedProbabilities""",""""""
"""""","""PredcitionAppenderCustomizer""",""""""
"""""","""_[tT][eE][sS][tT]_[0-9]+_[oO][fF]_[0-9]+""",""""""
"""""","""_test_""","""_eXg_"""
"""""","""... test set ""","""c eXg̓Zbg܂B"""
"""""","""_[tT][rR][aA][iI][nN][iI][nN][gG]_[0-9]+_[oO][fF]_[0-9]+""",""""""
"""""","""_training_""","""_g[jO_"""
"""""","""_of_""","""__ɂ"""
"""""","""... training set ""","""c g[jO̓Zbg܂B"""
"""""",""" for relation """,""" ֌Ŵ߂"""
"""""","""Instance ""","""CX^X"""
"""""",""" could not been saved""",""" ۑ邱Ƃł܂łB"""
"""""","""...relation ""","""....֌W"""
"""""",""" saved.""",""" ۑ"""
"""""","""File could not have been closed.""","""t@C邱Ƃł܂łB"""
"""""",""" : incorrect """,""" : sm"""
"""""","""type of algorithm (Loader)""","""ASỸ^Cv(וςސl)"""
"""""","""Property change!!""","""ڕύX!!"""
"""""","""Select directory and prefix""","""fBNgprefixIĂ"""
"""""",""" Database URL:          """,""" f[^x[XURL: """
"""""",""" Username:              """,""" [U: """
"""""",""" Password:              """,""" pX[h: """
"""""",""" Table Name:            """,""" e[u: """
"""""",""" Use relation name:     """,""" ֌Wgp: """
"""""",""" Automatic primary key: """,""" L[: """
"""""","""Directory""","""fBNg"""
"""""",""" Prefix for file name:""",""" t@Ĉ߂Prefix:"""
"""""","""Visualize incoming data/training/test sets in a scatter ""","""Uzœėf[^/g[jO/eXgEZbgzĂB"""
"""""","""plot matrix.""","""}gNX`"""
"""""","""ScatterPlotMatrix""","""񎟌vbg"""
"""""","""This method is not to be used during design ""","""̃\bh̓fUC̊ԁAgpȂƂłB"""
"""""","""time. It is meant to be used if this ""","""ԁB ͂łȂgp邱ƂɂȂĂ܂B"""
"""""","""bean is being used programatically as as ""","""Agp̂programaticallyłB"""
"""""","""stand alone component.""","""PƂ̃R|[lgɑςĂB"""
"""""","""Show plot""","""AdĂB"""
"""""",""" not supported (ScatterPlotMatrix)""",""" x܂B(ScatterPlotMatrix)"""
"""""","""Usage: ScatterPlotMatrix <dataset>""","""p@: ScatterPlotMatrix<f[^Zbg>"""
"""""","""StripChart""",""""""
"""""","""Visualize incremental classifier performance as a scrolling plot.""","""XN[AdƂđ̃NVt@CA\zĂB"""
"""""","""Show x axis labels this often""","""΂΂x̂xɎĂB"""
"""""","""Plot every x'th data point""","""x'thf[^|CgvbgĂB"""
"""""","""99000""",""""""
"""""","""Strip Chart""","""XgbvE`[g"""
"""""","""Legend""","""`"""
"""""","""Interrupting""","""f܂"""
"""""","""Starting handler""","""Jn"""
"""""","""Show chart""","""}\"""
"""""",""" not supported (StripChart)""",""" x܂B(StripChart)"""
"""""","""Weka Knowledge Flow : StipChart""","""Weka Knowledge Flow: Xvbg`[g"""
"""""","""Done sending data""","""f[^𑗂IĂ܂B"""
"""""","""xLabelFreq""",""""""
"""""","""refreshFreq""",""""""
"""""","""StripChartCustomizer""",""""""
"""""","""TestSetMaker""",""""""
"""""","""Designate an incoming data set as a test set.""","""eXgZbĝŁAėf[^Zbgw肵ĂB"""
"""""","""TextViewer""",""""""
"""""","""General purpose text display.""","""ėp̃eLXgfBXvCB"""
"""""","""Text Viewer""","""eLXgr[A["""
"""""","""Text""","""eLXg"""
"""""","""Show results""","""ʂ߂ĂB"""
"""""","""Clear results""","""mȌ"""
"""""",""" not supported (TextViewer)""",""" x܂B(TextViewer)"""
"""""","""Here is some test text from the main ""","""ɁAC̉炩̃eXgeLXg܂B"""
"""""","""method of this class.""","""̃NX̃\bhB"""
"""""","""The Title""","""^Cg"""
"""""","""TrainingSetMaker""",""""""
"""""","""Designate an incoming data set as a training set.""","""g[jOZbĝŁAėf[^Zbgw肵ĂB"""
"""""","""In accept data set""","""ł́Af[^Zbg͎󂯓܂B"""
"""""","""Notifying listeners (training set maker)""","""Xi[ɒʒm܂B(g[jOZbg[J[)"""
"""""","""TrainTestSplitMaker""","""PEeXgf[^Zbg"""
"""""","""Split an incoming data set into separate train and test sets.""","""ėf[^ZbgʁX̗ԂƃeXgEZbgɕĂB"""
"""""","""The percentage of data to go into the training set""","""g[jOɓf[^̊̓Zbg܂B"""
"""""","""The randomization seed""","""_̎"""
"""""","""Split has been canceled!""","""͒~܂!"""
"""""","""Split maker interrupted""","""̐͒f܂B"""
"""""","""Notifying test listeners ""","""eXgXi[ɒʒm܂B"""
"""""","""Notifying training listeners ""","""g[jOXi[ɒʒm܂B"""
"""""","""(cross validation fold maker)""","""(@܂ڂ̃[J[Ɍ܂)"""
"""""","""Listener is BeanCommon""","""Xi[BeanCommonłB"""
"""""",""" not supported (TrainTestSplitMaker)""",""" x܂B(TrainTestSplitMaker)"""
"""""","""dataSet""","""f[^Zbg"""
"""""","""trainingSet""","""Pf[^Zbg"""
"""""","""testSet""","""eXgf[^Zbg"""
"""""","""trainPercent""","""Pf[^Zbg̊"""
"""""","""seed""",""""""
"""""","""TrainTestSplitMakerCustomizer""","""PEeXgf[^Zbg"""
"""""","""source_id""","""\[XID"""
"""""","""target_id""","""ړIhc"""
"""""","""eventname""",""""""
"""""","""hidden""",""""""
"""""","""file""","""t@C"""
"""""","""text""","""eLXg"""
"""""","""width""",""""""
"""""","""height""",""""""
"""""","""iconPath""",""""""
"""""","""animatedIconPath""",""""""
"""""","""associatedConnections""",""""""
"""""","""inputs""",""""""
"""""","""inputs_id""","""_ID"""
"""""","""outputs""","""o"""
"""""","""outputs_id""","""o_ID"""
"""""","""subFlow""",""""""
"""""","""originalCoords""",""""""
"""""","""regular_connection""","""M[_ڑ"""
"""""","""DataType '""","""'f[^^'"""
"""""","""' is unknown!""","""'͕sł'"""
"""""","""actionMap""",""""""
"""""","""alignmentX""",""""""
"""""","""alignmentY""",""""""
"""""","""autoscrolls""",""""""
"""""","""background""",""""""
"""""","""border""",""""""
"""""","""componentPopupMenu""",""""""
"""""","""debugGraphicsOptions""",""""""
"""""","""doubleBuffered""",""""""
"""""","""focusCycleRoot""",""""""
"""""","""focusTraversalPolicy""",""""""
"""""","""focusTraversalPolicyProvider""",""""""
"""""","""focusable""",""""""
"""""","""font""",""""""
"""""","""foreground""",""""""
"""""","""inheritsPopupMenu""",""""""
"""""","""inputVerifier""",""""""
"""""","""layout""",""""""
"""""","""locale""",""""""
"""""","""maximumSize""",""""""
"""""","""minimumSize""",""""""
"""""","""nextFocusableComponent""",""""""
"""""","""opaque""",""""""
"""""","""preferredSize""",""""""
"""""","""requestFocusEnabled""",""""""
"""""","""toolTipText""",""""""
"""""","""transferHandler""",""""""
"""""","""verifyInputWhenFocusTarget""",""""""
"""""","""visible""",""""""
"""""","""size""",""""""
"""""","""location""",""""""
"""""","""bean""",""""""
"""""","""saver""",""""""
"""""","""loader""",""""""
"""""","""beanContext""",""""""
"""""","""filter""",""""""
"""""","""wrappedAlgorithm""",""""""
"""""","""debug""",""""""
"""""","""options""",""""""
"""""","""Color""",""""""
"""""","""Dimension""",""""""
"""""","""Font""",""""""
"""""","""Point""",""""""
"""""","""ColorUIResource""",""""""
"""""","""FontUIResource""",""""""
"""""","""BeanInstance""",""""""
"""""","""BeanConnection""",""""""
"""""","""BeanVisual""",""""""
"""""","""BeanSaver""",""""""
"""""","""MetaBean""",""""""
"""""","""Loader""",""""""
"""""","""Saver""",""""""
"""""","""addBeanInstances does not support Vectors of class '""","""'addBeanInstances̓NXVectorsT|[g܂'"""
"""""","""writePreProcess: data type '""","""writePreProcess: 'f[^^'"""
"""""","""' is not recognized!""","""'FȂA!'"""
"""""","""name""",""""""
"""""","""WARNING: '""","""x: '"""
"""""","""' is not a recognized name for ""","""'aFꂽOłȂA'"""
"""""","""WARNING: unknown loader class '""","""x: 'm̉וςސl̃NX'"""
"""""","""WARNING: The file '""","""x: 't@C'"""
"""""","""' does not exist!""","""'݂ĂȂA!'"""
"""""","""WARNING: unknown saver class '""","""x: 'm̒~Ƃ̃NX'"""
"""""","""' - cannot retrieve file!""","""'--t@C邱ƂłȂA!'"""
"""""","""INFO: '""","""CtH[V: '"""
"""""","""' will be restored later.""","""'ŉ񕜂ł傤'B"""
"""""","""No class attribute set (BoundaryPanel)""","""NX͑SZbg܂łB(BoundaryPanel)"""
"""""","""Too few distinct values for X attribute ""","""X̂߂̂܂ɂ킸ȈقȂl"""
"""""","""X attribute out of range (BoundaryPanel)""","""͈͂X(BoundaryPanel)"""
"""""","""Too few distinct values for Y attribute ""","""Ŷ߂̂܂ɂ킸ȈقȂl"""
"""""","""Usage : BoundaryPanel <dataset> ""","""p@: BoundaryPanel<f[^Zbg>"""
"""""","""No hosts specified!""","""ǂȃzXgw肵܂ł!"""
"""""","""(BoundaryPanel)""",""""""
"""""","""Max failures exceeded for host ""","""zXĝ߂ɒꂽ}bNX̎s"""
"""""",""". Removed from host list.""",""".. zXgXgAO܂B"""
"""""","""Plotting aborted! Max failures ""","""݂͒~ɂȂ܂! }bNX̎s"""
"""""","""exceeded on all remote hosts.""","""ׂẴ[gzXgł́A܂B"""
"""""","""exp q :""","""exp q:"""
"""""","""host list size ""","""zXgXgTCY"""
"""""","""actual host list size ""","""ۂ̃zXgXgTCY"""
"""""","""removed hosts ""","""菜ꂽzXg"""
"""""","""Plotting completed successfully.""","""悭݁B"""
"""""","""Plotting aborted. All remote tasks ""","""݂͒~ɂȂ܂B ׂẴ[g^XN"""
"""""","""finished.""","""IB"""
"""""","""Plotting aborted! All connections ""","""݂͒~ɂȂ܂! ׂĂ̐ڑ"""
"""""","""to remote hosts failed.""","""[gɁAzXg͎s܂B"""
"""""","""Starting row ""","""n߂̗"""
"""""",""" on host """,""" zXgɊւ"""
"""""",""". Scheduling for execution on another host.""",""".. ŝ߂ɁAʂ̃zXg̏Ōv܂B"""
"""""","""seconds""","""b"""
"""""","""minutes""",""""""
"""""","""hours""",""""""
"""""",""" (approx. time remaining """,""" (͂Ŏc𒲐߂ĂB"""
"""""","""% complete""","""% I"""
"""""",""" queued on """,""" ܂B"""
"""""","""Connection to ""","""ڑ"""
"""""",""" failed. Scheduling row """,""" sɂB XPW[O"""
"""""",""" for execution on another host.""",""" ʂ̃zXgɂŝ߂ɁB"""
"""""","""Sub exp Interupted!""","""exp Interupted!"""
"""""","""Usage : BoundaryPanelDistributed <dataset> ""","""p@: BoundaryPanelDistributed<f[^Zbg>"""
"""""","""<class col> <xAtt> <yAtt> """,""""""
"""""","""<base> <# loc/pixel> <kernel bandwidth> """,""""""
"""""","""<display width> """,""""""
"""""","""<display height> <classifier """,""""""
"""""","""Adding host ""","""zXgǉ"""
"""""","""No hosts.vis file - create this file in ""","""hosts.vist@C܂--쐬̂͗ČJ荞݂܂B"""
"""""","""the current directory with one host name ""","""1̃zXgJgfBNg"""
"""""","""per line, or use BoundaryPanel instead.""","""ԂA܂͑BoundaryPanelgpĂB"""
"""""","""No color map file""","""F}bvt@C܂D"""
"""""","""Plot training data""","""Pf[^Zbgvbg"""
"""""","""Class Attribute""","""NX"""
"""""","""Visualization Attributes""","""̉"""
"""""","""Sampling control""","""W{oRg["""
"""""",""" Base for sampling (r)""",""" W{ô߂̊{ (r)"""
"""""",""" Num. locations per pixel""",""" 1f̈ʒu"""
"""""",""" Kernel bandwidth (k)""",""" J[lш敝 (k)"""
"""""","""Plotting""","""vbg"""
"""""","""Class color""","""NXF"""
"""""","""Not enough attributes in the data to visualize!""","""f[^̑z邱Ƃł邭炢̑łȂ!"""
"""""","""Usage : BoundaryPanel <dataset> <classifier ""","""p@: BoundaryPanel(<f[^Zbg>)<NVt@CA"""
"""""","""[classifier options]>""","""NVt@CAIvV>"""
"""""","""Weka classification boundary visualizer""","""Weka ދE"""
"""""","""Loading instances from : ""","""ȉ̃[fBO """
"""""","""All training instances coincide with ""","""ႪvĂ邷ׂẴg[jO"""
"""""","""test instance!""","""eXgCX^X!"""
"""""","""No training data set (BoundaryPanel)""","""g[jOf[^Zbg܂B(BoundaryPanel)"""
"""""","""No classifier set (BoundaryPanel)""","""ǂȃNVt@CAZbg܂łB(BoundaryPanel)"""
"""""","""No data generator set (BoundaryPanel)""","""f[^[l[^͑SZbg܂łB(BoundaryPanel)"""
"""""","""Visualization dimensions must be numeric ""","""z@͐lłɈႢ܂B"""
"""""","""(RemoteBoundaryVisualizerSubTask)""",""""""
"""""","""Executing row number ""","""sԍs܂B"""
"""""",""" failed.""",""" sɂB"""
"""""","""Row ""","""ʂ"""
"""""",""" completed successfully.""",""" 悭܂B"""
"""""","""Input...""","""͂܂B"""
"""""","""Cost files""","""t@CĂB"""
"""""","""Defaults""","""ftHg"""
"""""","""Error reading file '""","""t@Cǂݍ݃G[ '"""
"""""","""Load failed""","""ǂݍݎs"""
"""""","""Error writing file '""","""'t@C݃G['"""
"""""","""Save failed""","""ۑs"""
"""""","""X x X matrix""","""X x X s"""
"""""",""" cost matrix""",""" RXgs"""
"""""","""new CostMatrix(""","""VRXgs("""
"""""","""CostMatrixEditor: ""","""RXgsҏW: """
"""""","""CostMatrix properties cannot be ""","""CostMatrix̓͂ł͂܂B"""
"""""","""expressed as text""","""eLXgƂāA\܂B"""
"""""","""Database Connection Parameters""","""f[^x[Xڑp^"""
"""""",""" Database URL:""",""" f[^x[XURL:"""
"""""",""" Username:    """,""" [U: """
"""""",""" Password:    """,""" pX[h: """
"""""","""URL""",""""""
"""""","""username""","""[U"""
"""""","""Edit selected...""","""IҏWc"""
"""""","""Load options...""","""IvV[hc"""
"""""","""Save options...""","""IvVۑc"""
"""""","""Algorithms""","""ASY"""
"""""","""AlgorithmListPanel: Problem copying object""","""AlgorithmListPanel: IuWFNg̃Rs[ɖ肪"""
"""""","""Algorithm List Editor""","""ASYXgGfB^"""
"""""","""Add new...""","""Vɒǉc"""
"""""","""Use relative paths""","""΃pXgpĂD"""
"""""","""Store file paths relative to ""","""t@C̃pX"""
"""""","""the start directory""","""X^[gfBNgɊ֘AĂD"""
"""""","""Datasets""","""f[^Zbg"""
"""""","""IOError occured when reading list of files""","""IOErrort@Cǂݍݒɔ"""
"""""","""User dir """,""""""
"""""","""Target path ""","""ڕWpX"""
"""""","""Can't construct a path to file relative to user ""","""[ŨfBNgɊ֘At@Cւ̃pX͍\zł܂łD"""
"""""","""dir.""",""" """
"""""","""new path : ""","""VoH: """
"""""","""By data set""","""f[^Zbgɂ"""
"""""","""By run""","""sɂ"""
"""""","""Allow this experiment to be distributed to remote hosts""","""̎[gzXgɕU\ɂ܂D"""
"""""","""Edit the list of remote hosts""","""[gzXg̃XgҏWĂB"""
"""""","""Distribute experiment by data set""","""f[^Zbgɂ镪U"""
"""""","""Distribute experiment by run number""","""sԍɂ镪U"""
"""""","""Distribute experiment""","""U"""
"""""","""Edit host names""","""zXg̕ҏW"""
"""""","""DistributeExperiment""",""""""
"""""","""Set up the experiment""","""ݒ"""
"""""","""Run""","""s"""
"""""","""Run the experiment""","""s"""
"""""","""Analyse""",""""""
"""""","""Analyse experiment results""","""ʂ𕪐"""
"""""","""Updated experiment""","""Abvf[gꂽ"""
"""""","""CLASS_FIRST""",""""""
"""""","""Problem reading properties. Fix before continuing.""","""Ǐ̓B OɁACĂB"""
"""""","""Extension""",""""""
"""""","""ExperimentType""",""""""
"""""","""UseClassification""",""""""
"""""","""TrainPercentage""",""""""
"""""","""Repetitions""",""""""
"""""","""DatasetsFirst""",""""""
"""""","""InitialDatasetsDirectory""",""""""
"""""","""UseRelativePaths""",""""""
"""""","""ComparisonField""",""""""
"""""","""percent_correct""","""̃p[Ze[W"""
"""""","""ShowStdDev""","""W΍̕\"""
"""""","""MeanPrecision""","""ϗ\"""
"""""","""StdDevPrecision""","""\̕W΍"""
"""""","""Select property...""","""vpeBIĂc"""
"""""","""Disabled""",""""""
"""""","""Enabled""","""L"""
"""""","""Generator properties""","""WFl[^̓"""
"""""","""Updating experiment property iterator array""","""̌JԂqzAbvf[g܂B"""
"""""","""Set new array to array editor""","""VzɃGfB^𐮗񂳂悤ɐݒ肵ĂB"""
"""""","""Editor status change""","""GfB^ԕύX"""
"""""","""Generator Property Iterator""","""WFl[^̌JԂq"""
"""""","""Delete selected""","""I폜"""
"""""","""Hosts""","""zXg"""
"""""","""Host List Editor""","""zXgXgGfB^"""
"""""","""Plain Text""","""v[eLXg"""
"""""","""LaTeX""",""""""
"""""","""CSV""",""""""
"""""","""Output Format...""","""o͌`c"""
"""""","""Mean Precision""","""ϗ\"""
"""""","""StdDev. Precision""","""W΍D\"""
"""""","""Accepted""","""܂"""
"""""","""Aborted""","""~܂"""
"""""","""No source""","""\[X܂"""
"""""","""File...""","""t@Cc"""
"""""","""Database...""","""f[^x[Xc"""
"""""","""Experiment""",""""""
"""""","""Column""",""""""
"""""","""Select base...""","""x[XIĂc"""
"""""","""Perform test""","""eXgs"""
"""""","""Save output""","""o͂̕ۑ"""
"""""","""Performs test using corrected resampled t-test statistic (Nadeau and Bengio)""","""Nadeau and Bengioɂcorrected resampled t-s"""
"""""","""Result list""","""ʃXg"""
"""""","""Source""","""\[X"""
"""""","""Configure test""","""eXg̐ݒ"""
"""""","""Comparison field""","""rtB[h"""
"""""","""Significance""","""L"""
"""""","""Test base""","""eXgx[X"""
"""""","""Displayed Columns""","""\ꂽR"""
"""""","""Show std. deviations""","""W΍̕\"""
"""""","""Output Format""","""o͌`"""
"""""","""Test output""","""eXgo"""
"""""","""Enter the database URL""","""f[^x[XURLɓĂB"""
"""""","""Query Database""","""f[^x[X"""
"""""","""not found""","""܂B"""
"""""","""No experiment index""","""CfbNX܂B"""
"""""","""found""","""܂B"""
"""""","""Getting experiment index""","""CfbNX𓾂܂B"""
"""""","""No experiments available""","""p\Ȏ܂B"""
"""""","""Got experiment index""","""CfbNX𓾂܂B"""
"""""","""Problem reading database: '""","""Ǐf[^x[X: '"""
"""""","""No result file""","""ʃt@C܂B"""
"""""","""Problem reading database""","""Ǐf[^x[X"""
"""""","""Can't get results from experiment""","""琬ʂ߂邱Ƃł܂B"""
"""""","""Reading from database, please wait...""","""f[^x[XǂŁA҂Ăc"""
"""""","""SELECT * FROM ""","""""",""""""
"""""","""list""","""Xg"""
"""""","""Got ""","""܂B"""
"""""",""" results""",""" """
"""""","""Key_Dataset""","""v_f[^Zbg"""
"""""","""Key_Scheme,Key_Scheme_options,Key_Scheme_version_ID""","""v_vAv_v_IvVAv_v_o[W_ID"""
"""""","""key_""","""v_"""
"""""","""key_run""","""v_s"""
"""""","""key_fold""","""v_܂"""
"""""","""root_relative_squared_error""","""_e__悵܂B"""
"""""","""Available resultsets""","""p\Ȍ"""
"""""","""Available resultsets\n""","""p\Ȍ\n"""
"""""","""Summary""","""Tv"""
"""""","""Ranking""","""LO"""
"""""","""File saved""","""t@C͕ۑ܂B"""
"""""","""Results""",""""""
"""""","""Weka Experiment: Results Analysis""","""Weka : ʕ"""
"""""","""Runs""","""s"""
"""""","""Dataset List Editor""","""f[^ZbgXg̕ҏW"""
"""""","""Not running""","""sĂ܂"""
"""""","""Null experiment!!!""","""ݒ薳!"""
"""""","""Running experiment: ""","""s: """
"""""","""Writing experiment copy""","""Rs[ݒ"""
"""""","""Reading experiment copy""","""Rs[ǂݍݒ"""
"""""","""Made experiment copy""","""Rs[쐬"""
"""""","""Adding a listener""","""Xi[ǉ"""
"""""","""Started""","""Jn"""
"""""","""Initializing...""","""c"""
"""""","""Iterating...""","""JԂc"""
"""""",""" Dataset=""",""" f[^Zbg="""
"""""",""" Run=""",""" s="""
"""""","""Postprocessing...""","""㏈..."""
"""""","""Finished""","""I"""
"""""","""There was ""","""G["""
"""""",""" error""",""" """
"""""","""There were ""","""G["""
"""""",""" errors""",""" """
"""""","""Remote experiment running...""","""[gғc"""
"""""","""Done...""","""I܂c"""
"""""","""Problem creating experiment copy to run: ""","""sRs[쐬邱Ƃɂ: """
"""""","""User aborting experiment. ""","""[Uɂ~D"""
"""""","""Waiting for remote tasks to ""","""[g^XN҂Ă܂"""
"""""","""complete...""","""c"""
"""""","""Run Weka Experiment""","""Weka s"""
"""""","""\nExperiment Configuration\n""","""\nݒ\n"""
"""""","""Simple""","""ȈՐݒ"""
"""""","""Advanced""","""xȐݒ"""
"""""","""Experiment Configuration Mode:""","""̐ݒ胂[h:"""
"""""","""Custom generator first""","""JX^WFl[^CŏɁD"""
"""""","""Result generator""","""ʃWFl[^"""
"""""","""Destination""","""o͐"""
"""""","""Advance data set before custom generator""","""xȃf[^ZbgJX^WFl[^"""
"""""","""Advance custom generator before data set""","""xȃJX^WFl[^̑OɃf[^Zbg"""
"""""","""Iteration control""","""JԂRg["""
"""""","""A filename must be given with the -f option""","""-fIvVŃt@C^Ȃ΂Ȃ܂D"""
"""""","""Initial Experiment:\n""","""ŏ̎: \n"""
"""""","""Weka Experiment Setup""","""Weka ZbgAbv"""
"""""","""Setup""","""ZbgAbv"""
"""""","""\nFinal Experiment:\n""","""\nŏI̎: \n"""
"""""","""Couldn't write experiment to: ""","""eނƂł܂ł:"""
"""""","""Short nap""","""}ɁAQĂB"""
"""""","""Comma separated value files""","""R}ŋ؂ꂽl̃t@C(CSVt@C)"""
"""""","""ARFF files""","""ARFFt@C"""
"""""","""New""","""V"""
"""""","""Experiment configuration files (*""","""ݒt@C (*"""
"""""","""Experiment configuration files (*.xml)""","""ݒt@C (*.xml)"""
"""""","""Classification""","""ފwK"""
"""""","""Regression""","""A"""
"""""","""Data sets first""","""f[^ZbgD"""
"""""","""Algorithms first""","""ASYD"""
"""""","""JDBC database""","""JDBCf[^x[X"""
"""""","""ARFF file""","""ARFFt@C"""
"""""","""CSV file""","""CSVt@C"""
"""""","""Train/Test Percentage Split (data randomized)""","""P/eXg(f[^_)"""
"""""","""Train/Test Percentage Split (order preserved)""","""P/eXg(ۑ)"""
"""""","""Notes""",""""""
"""""","""Results Destination""","""ʂ̏o͐"""
"""""","""Experiment Type""","""^Cv"""
"""""","""Number of repetitions:""","""JԂ:"""
"""""","""Iteration Control""","""JԂRg["""
"""""","""This experiment has settings that are too advanced\n""","""̎́Cx߂ݒłD\n"""
"""""","""to be represented in the simple setup mode.\n""","""ȈՐݒ胂[hŕ\邽߂ɂ́D\n"""
"""""","""Do you want the experiment to be converted,\n""","""̐ݒϊ܂H\n"""
"""""","""losing some of the advanced settings?\n""","""̍xȐݒȂD\n"""
"""""","""Confirm conversion""","""ϊmF"""
"""""","""SimpleSetup incompatibility: unrecognised result destination""","""SimpleSetup̕sv: FĂȂʂ̏o͐"""
"""""","""SimpleSetup incompatibility: unrecognised split evaluator""","""SimpleSetup̕sv: FĂȂ]"""
"""""","""SimpleSetup incompatibility: unrecognised resultProducer""","""SimpleSetup̕sv: FĂȂʐ\bh"""
"""""","""SimpleSetup incompatibility: runLower is not 1""","""SimpleSetup̕sv: runLower1ł͂܂"""
"""""","""SimpleSetup incompatibility: unrecognised property iteration""","""SimpleSetup̕sv: FĂȂJԂ̐ݒ"""
"""""","""Opened experiment:\n""","""Jꂽݒ: \n"""
"""""","""Couldn't open experiment file:\n""","""ݒt@CJ܂: \n"""
"""""","""Open Experiment""","""ݒJ"""
"""""","""Saved experiment:\n""","""ۑݒ: \n"""
"""""","""Couldn't save experiment file:\n""","""ݒt@Cۑł܂: \n"""
"""""","""Save Experiment""","""ݒۑ"""
"""""","""User...""","""[Uc"""
"""""","""Browse...""","""uEYc"""
"""""","""weka_experiment""","""weka_"""
"""""","""Cannot create temp file, writing to standard out.""","""Wo͂ɏo߂̈ꎞt@C쐬邱Ƃł܂"""
"""""","""Number of folds:""","""܂ڂ̐:"""
"""""","""Train percentage:""","""Pf[^̊:"""
"""""","""splitEvaluator""",""""""
"""""","""classifier""",""""""
"""""","""not rsrp""",""""""
"""""","""Starts the associator""","""փ[wKASYsJn"""
"""""","""Stops the associator""","""փ[wKASYs~"""
"""""","""Associator""","""փ[wKASY"""
"""""","""Associator output""","""փ[wK̏o"""
"""""","""=== Associator model (full training set) ===\n\n""","""=== փ[wKf(Pf[^Zbgɑ΂) ===\n\n"""
"""""","""Weka Explorer: Associator""","""Weka GNXv[[: փ[wK"""
"""""","""Use full training set""","""Pf[^Zbggp"""
"""""","""Seed""",""""""
"""""","""You must use use the Ranker search method ""","""Ranker\bhgpȂ΂Ȃ܂D"""
"""""","""in order to use\n""","""gp邽߂\n"""
"""""",""".\nShould I select the Ranker search method for you?""",""".\nRanker\bhI܂?"""
"""""","""You must use use a search method that explores \n""","""\bhgpĂD\n"""
"""""","""the space of attribute subsets (such as GreedyStepwise) in ""","""Ă͑WXy[XT(GreedyStepwiseȂǂ̎@)"""
"""""","""order to use\n""","""邽߂Ɏg܂D\n"""
"""""",""".\nShould I select the GreedyStepwise search method for ""","""\nGreedyStepwise\bhI܂H\"""
"""""","""you?\n(you can always switch to a different method afterwards)""","""\n(łقȂ\bhɐ؂ւ邱Ƃł܂)"""
"""""","""single attributes (such as InfoGain) in order to use\n""","""Pꑮ̕](InfoGain̂悤ȕ]\bh)\n"""
"""""","""the Ranker. Should I select the InfoGain evaluator ""","""RankerƂĎg܂D InfoGain]\bhƂ"""
"""""","""for you?\n""","""I܂H\n"""
"""""","""(You can always switch to a different method afterwards)""","""(łقȂ\bhɐ؂ւ邱Ƃł܂)"""
"""""","""You must use use an evaluator that evaluates\n""","""]\bhgpĂD\n"""
"""""","""subsets of attributes (such as CFS) in order to use\n""","""̃\bh(CFŜ悤ȃ\bh)͑W]邽߂Ɏgp܂D"""
"""""",""".\nShould I select the CFS subset evaluator for you?""",""".. \nCFSW]\bhI܂?"""
"""""","""\n(you can always switch to a different method afterwards)""","""\n(łقȂ\bhɐ؂ւ邱Ƃł܂)"""
"""""","""Alert!""","""x!"""
"""""","""select attributes using the full training ""","""IĂD"""
"""""","""dataset""","""SĂ̌Pf[^ZbggpāD"""
"""""","""Starts attribute selection""","""IJn"""
"""""","""Stops a attribute selection task""","""I^XN~"""
"""""","""Attribute Evaluator""","""]"""
"""""","""Search Method""","""T@"""
"""""","""Attribute Selection Mode""","""I[h"""
"""""","""Attribute selection output""","""Io"""
"""""","""Evaluator:    ""","""]@: """
"""""","""\nSearch:       ""","""\nT: """
"""""","""Evaluation mode:    ""","""][h: """
"""""","""evaluate on all training data\n""","""Pf[^ł̕]\n"""
"""""","""Doing feature selection...""","""I𒆁c"""
"""""","""Selecting attributes using all but fold ""","""܂ڈȊÔׂĂgp邱ƂőI܂B"""
"""""","""Save succesful.""","""ۑD"""
"""""","""Weka Attribute Selection Visualize: ""","""Weka I: """
"""""","""Visualize reduced data""","""팸f[^̉"""
"""""","""Visualize transformed data""","""ϊf[^̉"""
"""""","""Weka Explorer: Select attributes""","""Weka GNXv[[: IĂD"""
"""""","""Cross-validation""",""""""
"""""","""Store predictions for visualization""","""̂߂ɗ\i["""
"""""","""Output model""","""fo"""
"""""","""Output per-class stats""","""1NX̓vo"""
"""""","""Output confusion matrix""","""so"""
"""""","""Output entropy evaluation measures""","""Ggs[]o"""
"""""","""Output predictions""","""\̏o"""
"""""","""Cost-sensitive evaluation""","""RXgl]"""
"""""","""Folds""","""܂Ԃ"""
"""""","""More options...""","""葽̃IvVc"""
"""""","""Random seed for XVal / % Split""","""XVal/%Split̂߂̃_̎"""
"""""","""Select the attribute to use as the class""","""NXƂĎgpւ̑I肵ĂB"""
"""""","""Test on the same set that the classifier""","""炢̃eXgݒ肵ANVt@CA"""
"""""","""Perform a n-fold cross-validation""","""n{̌Ă鍇@sĂB"""
"""""",""" test on the remainder""",""" c̃eXg"""
"""""","""Test on a user-specified dataset""","""[UɂĎw肳ꂽf[^Zbg̃eXg"""
"""""","""Starts the classification""","""ނn߂܂"""
"""""","""Stops a running classification""","""ނ̎s~"""
"""""","""Output the model obtained from the full training set""","""fSȃg[jOZbg肵o"""
"""""","""Output precision/recall & true/false""","""x/R[Ɩ{/Uŏo͂ĂB"""
"""""",""" positives for each class""",""" eNX̂߂̐"""
"""""","""Output the matrix displaying class confusions""","""NX\}gNXo͂ĂB"""
"""""","""Output entropy-based evaluation measures""","""Ggs[x[X̕]o͂ĂB"""
"""""","""Evaluate errors with respect to a cost matrix""","""p}gNXɊւČ]ĂB"""
"""""","""Include the predictions in the output buffer""","""o̓obt@ɂ\܂߂ĂB"""
"""""","""Classifier evaluation options""","""NVt@CA]IvV"""
"""""","""Classifier""","""NVt@CA"""
"""""","""Test options""","""eXgIvV"""
"""""","""Classifier output""","""NVt@CAo"""
"""""","""predicted+WhateverTheClassIsCalled""","""+ WhateverTheClassIsCalled\܂B"""
"""""","""predicted""","""\܂B"""
"""""","""_predicted""","""_\܂B"""
"""""","""Number of folds must be greater than 1""","""܂ڂ̐1ȏłɈႢ܂B"""
"""""","""-fold cross-validation\n""","""-Ă鍇@Ă\n܂d˂ĂB"""
"""""","""Evaluation cost matrix:\n""","""]p}gNX: \n"""
"""""","""=== Classifier model (full training set) ===\n\n""","""=== ފwKf(Pf[^Zbgɑ΂) ===\n\n"""
"""""","""\nTime taken to build model: ""","""\nf̍\zɂ: """
"""""",""" seconds\n\n""",""" b\n\n"""
"""""","""Evaluating on training data...""","""Pf[^Zbgŕ]c"""
"""""","""=== Predictions on training set ===\n\n""","""=== Pf[^Zbgł̗\ ===\n\n"""
"""""","""Evaluating on training data. Processed ""","""Pf[^Zbgŕ]DI"""
"""""","""=== Evaluation on training set ===\n""","""=== Pf[^Zbgł̕] ===\n"""
"""""","""Using random seed ""","""_̎gĂ܂"""
"""""","""Stratifying instances...""","""f[^ZbgKwc"""
"""""","""=== Predictions on test data ===\n\n""","""=== eXgf[^Zbgɑ΂\ ===\n\n"""
"""""","""Creating splits for fold ""","""܂ڂɏ]ĕ쐬"""
"""""","""Building model for fold ""","""܂ڂɑ΂郂f\z"""
"""""","""Evaluating model for fold ""","""܂ڂɑ΂郂f]"""
"""""","""=== Stratified cross-validation ===\n""","""=== Kw ===\n"""
"""""","""=== Cross-validation ===\n""","""===  ===\n"""
"""""","""Trouble parsing random seed value""","""_̎̒l͒ɕs"""
"""""","""Problem copying classifier: ""","""ފRs[̖: """
"""""","""=== Predictions on test split ===\n\n""","""=== eXgf[^Zbgɑ΂\ ===\n\n"""
"""""","""Evaluating on test split. Processed ""","""eXgf[^Zbgɑ΂ĕ]DI"""
"""""","""=== Evaluation on test split ===\n""","""=== eXgf[^Zbgɑ΂] ===\n"""
"""""","""=== Evaluation on test set ===\n""","""=== eXgf[^Zbgł̕] ===\n"""
"""""","""Problem evaluating classifier:\n""","""ފ]̖: \n"""
"""""","""Interrupted""","""f܂B"""
"""""","""Visualize classifier errors""","""ތ̉"""
"""""","""Visualize graph""","""Otւ̉"""
"""""","""Visualize margin curve""","""}[WJ[u̕`"""
"""""","""Visualize threshold curve""","""~Ȑ̉"""
"""""","""(Area under ROC = ""","""(ROCȐ̗̉̈="""
"""""","""Visualize cost curve""","""RXgȐ̉"""
"""""",""". (Class value """,""". (NXl"""
"""""","""Weka Classifier Graph Visualizer: ""","""Weka ފwKOt: """
"""""","""unable to visualize BayesNet""","""BayesNet邱Ƃł܂"""
"""""","""Weka Classifier Visualize: ""","""Weka ފ̉: """
"""""","""\n=== Classifier model ===\n\n""","""\n=== ފwKf===\n\n"""
"""""","""Re-evaluating classifier (""","""ފĕ] ("""
"""""","""=== Predictions on test set ===\n\n""","""=== eXgf[^Zbgɑ΂\ ===\n\n"""
"""""",""" inst#,    actual, predicted, error""",""" f[^,   , \, """
"""""",""", probability distribution""",""", mz"""
"""""","""Evaluating on test data. Processed ""","""eXgf[^Zbgł̕]DI"""
"""""",""" instances...""",""" CX^Xc"""
"""""","""Problem evaluationg classifier:\n""","""ފ]̖: \n"""
"""""","""Evaluate classifier""","""ފ]"""
"""""","""Problem evaluating classifier""","""ފ]̖"""
"""""","""Percentage split""","""w肵ăf[^Zbg𕪊"""
"""""","""Use training set""","""Pf[^Zbggp"""
"""""","""Supplied test set""","""pӂeXgf[^Zbg"""
"""""","""Classes to clusters evaluation""","""NX^O]ɑ΂NX"""
"""""","""Set...""","""ݒc"""
"""""","""Ignore attributes""","""𖳎"""
"""""","""Store clusters for visualization""","""̂߂ɃNX^ۑ"""
"""""","""Model object files""","""fIuWFNgt@C"""
"""""","""Result list (right-click for options)""","""ʃXg(IvV͉ENbN)"""
"""""","""Cluster the same set that the clusterer""","""ZbgȂɂ葽clustererɌQĂB"""
"""""",""" is trained on""",""" P܂B"""
"""""","""Train on a percentage of the data and""","""ăf[^̊ŌPĂB"""
"""""",""" cluster the remainder""",""" cQĂB"""
"""""","""Cluster a user-specified dataset""","""[UɂĎw肳ꂽf[^ZbgQĂB"""
"""""","""Evaluate clusters with respect to a""","""aɊւăNX^]ĂB"""
"""""",""" class""",""" NX"""
"""""","""Select the class attribute for class based""","""NX̂߂̃x[X̃NXIĂB"""
"""""",""" evaluation""",""" ]"""
"""""","""Starts the clustering""","""NX^OJn"""
"""""","""Stops a running clusterer""","""s̃NX^O~"""
"""""","""Store predictions in the result list for later ""","""̂߂ɌʃXg̗\ʂۑ"""
"""""","""visualization""",""""""
"""""","""Ignore attributes during clustering""","""NX^OɂĖ鑮"""
"""""","""Clusterer""","""NX^O@"""
"""""","""Cluster mode""","""NX^[h"""
"""""","""Clusterer output""","""NX^O@o"""
"""""","""(Nom) ""","""(`^)"""
"""""","""(Num) ""","""(l^)"""
"""""","""(Str) ""","""(^)"""
"""""","""Test Instances""","""eXgf[^"""
"""""","""cluster""","""NX^"""
"""""","""_clustered""",""""""
"""""","""Setting up...""","""ZbgAbvc"""
"""""","""Started ""","""Jn"""
"""""","""Percentage must be between 0 and 100""","""p[Ze[W0100̊ԂłKv܂"""
"""""","""Unknown test mode""","""m̌؃[h"""
"""""","""Class must be nominal for class based ""","""]̂߂̃NX"""
"""""","""evaluation!""","""`łȂ΂Ȃ܂"""
"""""","""=== Run information ===\n\n""","""=== s̏ ===\n\n"""
"""""","""Test mode:    ""","""؎@: """
"""""","""evaluate on training data\n""","""Pf[^Zbgł̕]\n"""
"""""","""split ""","""܂B"""
"""""","""% train, remainder test\n""","""w芄͌Pf[^ZbgƂāCc̓eXgf[^ZbgƂ܂\n"""
"""""","""user supplied test set: ""","""[U^eXgf[^Zbg: """
"""""",""" instances\n""",""" f[^Zbg\n"""
"""""","""Classes to clusters evaluation on training data""","""Pf[^ZbgɂăNX^]邽߂̃NX"""
"""""","""Building model on training data...""","""Pf[^Zbgɑ΂ăf\zc"""
"""""","""\n=== Clustering model (full training set) ===\n\n""","""\n=== NX^O(Pf[^Zbgɑ΂) ===\n\n"""
"""""","""Clustering training data...""","""Pf[^ZbgɂăNX^Osc"""
"""""","""=== Model and evaluation on training set ===\n\n""","""=== Pf[^Zbgł̌ʂƕ] ===\n\n"""
"""""","""Randomizing instances...""","""f[^_c"""
"""""","""Building model on training split...""","""ꂽPf[^Zbgɑ΂ăf\zc"""
"""""","""Evaluating on test split...""","""eXgf[^Zbgɑ΂ĕ]c"""
"""""","""=== Model and evaluation on test split ===\n""","""=== fƕeXgf[^ɑ΂] ===\n"""
"""""","""=== Model and evaluation on test set ===\n""","""=== fƃeXgf[^ɑ΂]===\n"""
"""""","""Test mode not implemented""","""ĂȂeXg[hł"""
"""""","""Finished ""","""I"""
"""""","""Interrupted ""","""f"""
"""""","""See error log""","""QL^Ă"""
"""""","""Weka Classifier Tree Visualizer: ""","""Weka ؂̉: """
"""""","""Weka Clusterer Visualize: ""","""Weka NX^Ỏ: """
"""""","""View in main window""","""CEBhEŕ\"""
"""""","""View in separate window""","""ʂ̃EBhEŕ\"""
"""""","""Save result buffer""","""ʃobt@ۑ"""
"""""","""Load model""","""f̓ǂݍ"""
"""""","""Save model""","""f̕ۑ"""
"""""","""Re-evaluate model on current test set""","""݂̃eXgf[^ZbgŃfĕ]"""
"""""","""Visualize cluster assignments""","""NX^蓖Ă"""
"""""","""Visualize tree""","""؂̉"""
"""""","""Save successful.""","""ۑD"""
"""""","""Saving model to file...""","""ft@Cɕۑc"""
"""""","""Save Failed""","""ۑs"""
"""""","""Saved model (""","""ۑꂽf ("""
"""""",""") to file '""",""") t@C '"""
"""""","""Loading model from file...""","""t@C烂fǂݍݒc"""
"""""","""Load Failed""","""ǂݍ݂Ɏs"""
"""""","""Loaded model from file '""","""'t@Cǂݍ܂ꂽf '"""
"""""","""HH:mm:ss - """,""""""
"""""",""" from file '""",""" t@C'"""
"""""","""=== Model information ===\n\n""","""=== f̏ ===\n\n"""
"""""","""Filename:     ""","""t@C: """
"""""","""Scheme:       ""","""wKXL[: """
"""""","""              [list of attributes omitted]\n""","""              [ȗ̃Xg]\n"""
"""""","""\nTraining data unknown\n""","""\nPf[^Zbg܂\n"""
"""""","""\n=== Clustering model ===\n\n""","""\n=== NX^Of ===\n\n"""
"""""","""No user test set has been opened""","""[Uw肵eXgf[^Zbg͊J܂ł"""
"""""","""Train and test set are not compatible""","""PƃeXgf[^ZbgɌ݊܂"""
"""""","""Evaluating on test data...""","""eXgf[^Zbgɂ]..."""
"""""","""Re-evaluating clusterer (""","""NX^O̍ĕ] ("""
"""""",""") on test set""",""") eXgf[^Zbgɑ΂"""
"""""","""\n=== Re-evaluation on test set ===\n\n""","""\n=== eXgf[^Zbgɂĕ] ===\n\n"""
"""""","""User supplied test set\n""","""[U^eXgf[^Zbg\n"""
"""""","""Relation:     ""","""֌W: """
"""""","""Instances:    ""","""CX^X: """
"""""","""Attributes:   """,""": """
"""""","""NOTE - if test set is not compatible then results are ""","""--eXgf[^ZbgɌ݊ꍇ"""
"""""","""unpredictable\n\n""","""ʂ͗\s\ł\n\n"""
"""""","""Finished re-evaluation""","""ĕ]I"""
"""""","""Problem evaluating clusterer:\n""","""NX^OASY̕]Ɋւ: \n"""
"""""","""Evaluate clusterer""","""NX^OASY̕]"""
"""""","""Problem evaluating clusterer""","""NX^OASY]̖"""
"""""","""Weka Explorer: Cluster""","""Weka GNXv[[: NX^"""
"""""","""EEEE, d MMMM yyyy""",""""""
"""""","""(c) 1999-2005 The University of Waikato, Hamilton,""","""(c) 1999-2005 CJgwAn~g"""
"""""",""" New Zealand""",""" j[W[h"""
"""""","""web: http://www.cs.waikato.ac.nz/~ml/weka""","""EFu: http://www.cs.waikato.ac.nz/~ml/weka """
"""""","""Started on ""","""n߂"""
"""""","""Welcome to the Weka Explorer""","""WekaGNXv[[ւ悤"""
"""""","""Preprocess""","""O"""
"""""","""Open/Edit/Save instances""","""JAҏWA܂͕ۑĂ"""
"""""","""Classify""","""ފwK"""
"""""","""Classify instances""","""CX^X𕪗"""
"""""","""Cluster""","""NX^O"""
"""""","""Identify instance clusters""","""CX^XNX^肵ĂB"""
"""""","""Associate""","""փ["""
"""""","""Discover association rules""","""փ[̔"""
"""""","""Select attributes""","""I"""
"""""","""Determine relevance of attributes""","""̓Kؓx"""
"""""","""Visualize""",""""""
"""""","""Explore the data""","""f[^̒T"""
"""""","""Before sleeping.""","""X[vO"""
"""""","""\nexiting""",""""""
"""""","""Open DB...""","""DBJc"""
"""""","""Edit...""","""ҏWc"""
"""""","""Remove""",""""""
"""""","""Apply""","""tB^Kp"""
"""""","""Binary serialized instances""","""oCi[ɃVACYꂽf[^Zbg"""
"""""","""C45 names files""","""C45 names`t@C"""
"""""","""CSV data files""","""CSVf[^t@C"""
"""""","""SELECT * FROM ?""","""""",""""""
"""""","""Open a set of instances from a database""","""f[^x[X1Zbg̃CX^XJĂB"""
"""""","""Undo the last change to the dataset""","""f[^Zbgւ̍Ō̕ωɖ߂ĂB"""
"""""","""Open the current dataset in a Viewer for editing""","""ҏŴ߂Vieweř݂̃f[^ZbgJĂB"""
"""""","""Save the working relation to a file""","""t@CƂ̊֌WłƕۑĂB"""
"""""","""Apply the current filter to the data""","""݂̃tB^f[^ɓKpĂB"""
"""""","""Current relation""","""ǂݍ񂾃f[^"""
"""""","""Attributes""",""""""
"""""","""Remove selected attributes.""","""Iꂽ"""
"""""","""Can't remove all attributes from data!\n""","""f[^SĂ̑邱Ƃ͂ł܂!\n"""
"""""","""Can't remove all attributes from data!""","""f[^SĂ̑邱Ƃ͂ł܂!"""
"""""","""Remove Attributes""",""""""
"""""","""Problem removing attributes: ""","""̖: """
"""""","""Problem removing attributes""","""̖"""
"""""","""Selected attribute""","""Iꂽ"""
"""""","""Filter""","""tB^"""
"""""","""The chosen attribute will also be used as the ""","""I΂ꂽ́C"""
"""""","""class attribute when a filter is applied.""","""tB^KpꂽۂɃNXƂȂ܂"""
"""""","""Visualize All""","""S̉"""
"""""","""Base relation is now ""","""݂̊[V"""
"""""",""" instances)""",""" CX^X)"""
"""""","""Problem setting base instances:\n""","""x[XCX^Xݒ蒆̖:\n"""
"""""","""Instances""","""CX^X"""
"""""","""Passing dataset through filter ""","""tB^Ƀf[^Zbgʂ܂"""
"""""","""Class (colour) needs to ""","""NX(F)́C"""
"""""","""be set for supervised ""","""tttB^̂߂"""
"""""","""filter.""","""Kvł"""
"""""","""Dataset is empty.""","""f[^Zbg͋łB"""
"""""","""Saving undo information""","""AhDۑ"""
"""""","""Problem filtering instances:\n""","""CX^XtB^O̖: \n"""
"""""","""Problem filtering instances: ""","""CX^XtB^O̖: """
"""""","""Problem filtering instances""","""CX^XtB^O̖"""
"""""","""Can't apply filter at this time,\n""","""̃tB^͓Kpł܂,\n"""
"""""","""Apply Filter""","""tB^̓Kp"""
"""""","""Problem connecting to database:\n""","""f[^x[XƂ̐ڑ̖: \n"""
"""""","""Can't save in C45 format,\n""","""C4.5`ŕۑ邱Ƃł܂\n"""
"""""","""as the selected class is numeric.""","""IꂽNXlł̂ŁD"""
"""""","""continuous.\n""","""Al\n"""
"""""","""Save c45 format""","""C4.5`ŕۑ"""
"""""","""Save binary serialized instances""","""oCi[VACYꂽ`Ńf[^Zbgۑ"""
"""""","""Can't save at this time,\n""","""͕ۑ邱Ƃł܂\n"""
"""""","""Save Instances""","""f[^Zbgۑ"""
"""""",""" failed to load """,""" [hɎs"""
"""""",""" failed to load '""",""" '[hɎs'"""
"""""","""Convert File""","""t@Cϊ"""
"""""","""Reading from file...""","""t@CAǂ݂c"""
"""""","""csv""",""""""
"""""","""C45 names""",""""""
"""""","""Unrecognized file type""","""FĂȂt@C̎"""
"""""",""" file.""",""" t@C"""
"""""","""File '""","""'t@C'"""
"""""","""' not recognised as an ""","""' ƂĔFĂȂ"""
"""""",""" file.\n""",""" t@CłD\n"""
"""""","""Use Converter""","""Ro[^gp"""
"""""","""Reading from database...""","""f[^x[XAǂݍݒc"""
"""""","""Problem executing DB query ""","""DBNGs̖"""
"""""","""Couldn't read from database:\n""","""f[^x[XǂݍނƂł܂ł: \n"""
"""""","""Reading from URL...""","""URLǂݍݒc"""
"""""","""Problem reading ""","""ǂݍݒ̖"""
"""""","""weka""",""""""
"""""","""Weka Explorer: Preprocess""","""Weka GNXv[[: O"""
"""""","""new File(""""","""VFile("""
"""""","""No file""","""t@C܂B"""
"""""","""Can't edit""","""ҏW邱Ƃł܂"""
"""""","""Delete""","""폜"""
"""""","""Add""","""ǉ"""
"""""","""Could not create an object copy""","""IuWFNgRs[쐬邱Ƃł܂łB"""
"""""","""Add the current item to the list""","""݂̍ڂXgɒǉĂB"""
"""""","""Delete the selected list item""","""I\ڂ폜ĂB"""
"""""","""No property editor for class: ""","""NX̃vpeBGfB^܂: """
"""""","""Hello""","""ɂ"""
"""""","""There""",""""""
"""""","""Bob""",""""""
"""""","""Could not determine the properties for the generic object\n""","""WFlbNIuWFNg\nœ肷邱Ƃł܂łB"""
"""""","""editor. This exception was produced:\n""","""GfB^B ̗O͍o܂:A\n"""
"""""","""Failed to read a property file for the ""","""̃t@Cǂ݂܂B"""
"""""","""generic object editor""","""WFlbNIuWFNgGfB^"""
"""""","""Could not read a configuration file for the generic object\n""","""WFlbNIuWFNg\n̍\t@CǂނƂł܂łB"""
"""""","""editor. An example file is included with the Weka distribution.\n""","""GfB^B ̃t@CWekazŊ܂܂ĂA\n"""
"""""",""""" and\n""",""""""
"""""","""GenericObjectEditor""",""""""
"""""","""Open...""","""Jc"""
"""""","""Load a configured object""","""\ꂽIuWFNg[hĂB"""
"""""","""Save...""","""ۑc"""
"""""","""Save the current configured object""","""݂̍\ꂽIuWFNgĂĂB"""
"""""","""Object not of type: ""","""^CvłȂIuWFNg: """
"""""","""Couldn't read object: ""","""IuWFNgǂނƂł܂ł: """
"""""","""Open object file""","""JĂIuWFNgt@C"""
"""""","""Couldn't write to file: ""","""t@C邽߂ɏƂł܂ł: """
"""""","""Save object""","""IuWFNgĂĂB"""
"""""","""GenericObjectEditor: Problem making backup object""","""GenericObjectEditor: 쐬obNAbvIuWFNg"""
"""""","""weka.""",""""""
"""""","""Warning: No configuration property found in\n""","""x: \nŌȂ\̓S"""
"""""","""for ""","""for"""
"""""","""Invalid property: ""","""̓: """
"""""","""enabled""","""\ɂ܂B"""
"""""","""Problem loading the first class: ""","""ꗬ[h邱Ƃɂ: """
"""""","""No ClassType set up for GenericObjectEditor!!""","""ǂClassTypeGenericObjectEditor咣܂!"""
"""""","""setValue object not of correct type!""","""setValue͂ǂȐ^CvɂĂ΂܂!"""
"""""","""new ""","""V"""
"""""","""Choose""","""I"""
"""""","""root""",""""""
"""""","""Could not create an example of\n""","""\n̗쐬邱Ƃł܂łB"""
"""""","""from the current classpath""","""݂classpath"""
"""""","""Class load failed""","""NX׏d͎s܂B"""
"""""","""_blank""","""_"""
"""""","""template""","""ev[g"""
"""""","""Loading '""","""'[fBO'"""
"""""","""Problem with '""","""'A'"""
"""""","""Saving '""","""'~܂'B"""
"""""",""" Customises the list of options given by the GenericObjectEditor\n# for various superclasses.""",""" GenericObjectEditor\PʂŗlXȁuX[p[-NXv̂߂n#lāAIvṼXgJX^݌v܂B"""
"""""","""usage: ""","""p@: """
"""""",""" [<input.props>] [<output.props>]""",""" <input.props><output.props>"""
"""""","""No input given""","""^Ȃ͑S"""
"""""","""NETWORK""","""lbg[N"""
"""""","""NETWORK tag not found""","""NETWORK^O܂"""
"""""","""The name of the network is ""","""̃lbg[N̖O"""
"""""","""VARIABLE""","""ϐ"""
"""""","""NAME""","""O"""
"""""","""More than one name tags found for ""","""LȔꂽ1ȏ̖D"""
"""""","""variable no. ""","""No."""
"""""","""PROPERTY""",""""""
"""""","""position""","""ʒu"""
"""""","""OUTCOME""",""""""
"""""","""Outcome[""",""""""
"""""","""DEFINITION""","""`"""
"""""","""FOR""",""""""
"""""","""GIVEN""","""^܂B"""
"""""","""TABLE""","""e[u"""
"""""","""More than one Probability Table for ""","""1Probability Table"""
"""""",""" contains more values than it should""",""" ܗLA葽̒lׂ͂łB"""
"""""","""Probability Table for ""","""mAe[ȕɒuB"""
"""""",""" contains less values than it should""",""" ܗLA菭Ȃlׂ͂łB"""
"""""","""<?xml version=""1.0""?>\n""",""""""
"""""","""<!-- DTD for the XMLBIF 0.3 format -->\n""",""""""
"""""","""<!DOCTYPE BIF [\n""",""""""
"""""","""	<!ELEMENT BIF ( NETWORK )*>\n""",""""""
"""""","""	      <!ATTLIST BIF VERSION CDATA #REQUIRED>\n""",""""""
"""""","""	<!ELEMENT NETWORK ( NAME, ( PROPERTY | VARIABLE | DEFI""",""""""
"""""","""	<!ELEMENT NAME (#PCDATA)>\n""",""""""
"""""","""	<!ELEMENT VARIABLE ( NAME, ( OUTCOME |  PROPERTY )* )""",""""""
"""""","""	      <!ATTLIST VARIABLE TYPE (nature|decision|utility""",""""""
"""""","""	<!ELEMENT OUTCOME (#PCDATA)>\n""",""""""
"""""","""	<!ELEMENT DEFINITION ( FOR | GIVEN | TABLE | PROPERTY""",""""""
"""""","""	<!ELEMENT FOR (#PCDATA)>\n""",""""""
"""""","""	<!ELEMENT GIVEN (#PCDATA)>\n""",""""""
"""""","""	<!ELEMENT TABLE (#PCDATA)>\n""",""""""
"""""","""	<!ELEMENT PROPERTY (#PCDATA)>\n""",""""""
"""""","""<BIF VERSION=""0.3"">\n""",""""""
"""""","""<NETWORK>\n""",""""""
"""""","""<NAME>""",""""""
"""""","""<VARIABLE TYPE=""nature"">\n""",""""""
"""""","""\t<NAME>""",""""""
"""""","""\t<OUTCOME>""",""""""
"""""","""\t<PROPERTY>position = (""",""""""
"""""","""<DEFINITION>\n""",""""""
"""""","""<FOR>""",""""""
"""""","""\t<GIVEN>""",""""""
"""""","""<TABLE>\n""",""""""
"""""","""&amp;""",""""""
"""""","""&apos;""",""""""
"""""","""&quot;""",""""""
"""""",""" ignoring token """,""" ے𖳎܂B"""
"""""","""Error. Undirected graphs cannot be used""","""B UndirectedOtgp邱Ƃł܂B"""
"""""","""Error. Expected graph or digraph at line ""","""B \zꂽOtnɂA"""
"""""",""" in stmt""",""" stmt"""
"""""","""error at lineno ""","""linenǒ"""
"""""",""" in stmtException""",""" stmtException"""
"""""","""Added node >""",""""""
"""""","""Added edge from ""","""܂B"""
"""""",""". Cannot deal with undirected edges""",""".. wꂽɑΏ邱Ƃł܂B"""
"""""","""Error at line ""","""nɂ"""
"""""",""" in edgeStmt""",""" edgeStmt"""
"""""","""found label ""","""xݗĂB"""
"""""","""couldn't find label at line ""","""Ńx邱Ƃł܂łB"""
"""""","""couldn't find color at line ""","""@o͐ŒF邱Ƃł܂łB"""
"""""","""couldn't find style at line ""","""ŃX^C邱Ƃł܂łB"""
"""""","""digraph ""","""A"""
"""""","""returning true, n.ID >""","""{̖߂Ăn.ID>"""
"""""","""< this.ID >""","""<this.ID>"""
"""""","""save.gif not found for weka.gui.graphvisualizer.Graph""","""save.gifweka.gui.graphvisualizer.Graph̗LȔ܂łB"""
"""""","""Save Graph""","""OtۑĂB"""
"""""","""DOT files""","""DOTt@C"""
"""""","""XML BIF files""","""XML BIFt@C"""
"""""","""Save Graph As""","""Otۑ܂B"""
"""""","""Saving to file """"","""t@CߖAuv"""
"""""","""zoomin.gif not found for weka.gui.graphvisualizer.Graph""","""zoomin.gifweka.gui.graphvisualizer.Graph̗LȔ܂łB"""
"""""","""Zoom In""","""摜XɊg債ĂB"""
"""""","""zoomout.gif not found for weka.gui.graphvisualizer.Graph""","""zoomout.gifweka.gui.graphvisualizer.Graph̗LȔ܂łB"""
"""""","""Zoom Out""","""摜XɉďkĂB"""
"""""","""100%""",""""""
"""""","""Zoom""","""Y["""
"""""","""Invalid integer entered for zoom.""","""̐̓Y[ɎQ܂B"""
"""""","""Zoom is: ""","""Y[͈ȉ̒ʂłB """
"""""","""extra.gif not found for weka.gui.graphvisualizer.Graph""","""extra.gifweka.gui.graphvisualizer.Graph̗LȔ܂łB"""
"""""","""Show/Hide extra controls""","""tIȃRg[邩A܂͉BĂB"""
"""""","""Custom Node Size""","""JX^m[hTCY"""
"""""","""Width""",""""""
"""""","""Height""",""""""
"""""","""Layout Graph""","""CAEgOt"""
"""""","""Invalid integer entered for node width.""","""̐̓m[hɎQ܂B"""
"""""","""Invalid integer entered for node height.""","""̐̓m[h̍ɎQ܂B"""
"""""","""Error""",""""""
"""""","""ExtraControls""",""""""
"""""","""Scale: ""","""XP[: """
"""""",""" paddedWidth: """,""""""
"""""",""" nodeHeight: """,""""""
"""""","""\nmaxX: """,""""""
"""""",""" maxY: """,""""""
"""""",""" final: """,""" : """
"""""","""Size set to ""","""ZbgꂽTCY"""
"""""","""BIF format error""","""BIF`"""
"""""",""" (click to view the probability dist. table)""",""" (mNbN. e[udist܂)"""
"""""","""drawing ""","""}"""
"""""","""Original base ""","""̃x[X"""
"""""",""" hyp """,""" hyp"""
"""""","""\ntheta ""","""\ntheta"""
"""""",""" beta """,""" x[^"""
"""""","""Drawing 1 from ""","""1𓾂܂B"""
"""""",""" cos(theta-beta) """,""" cos(theta-x[^) """
"""""","""Drawing 2 from ""","""2𓾂܂B"""
"""""",""" x1,y1 is """,""" x1Ay1͂łB"""
"""""",""" base """,""" x[X"""
"""""",""" perp """,""" perp"""
"""""","""Drawing edges of ""","""`܂B"""
"""""","""in while processing ""","""ł́A߂ĂB"""
"""""","""Drawing from ""","""`܂B"""
"""""","""Too many outcomes of parents (""","""ê܂ɑ̌ʁA("""
"""""",""") can't display probabilities""",""") m\邱Ƃł܂B"""
"""""","""n.probs.length ""","""nBprobs.length"""
"""""","""n.probs[0].length ""","""nBprobs0.length"""
"""""",""" should be """,""" ׂłB"""
"""""","""probabilities are: ""","""m͈ȉ̒ʂłB """
"""""","""Preferred width ""","""ŝ悢"""
"""""","""lengths[j]: ""","""j: """
"""""",""" tempd.width: """,""""""
"""""","""After adding ""","""ť"""
"""""","""Probability Distribution Table For ""","""mze[u"""
"""""","""Preferred Size: ""","""DTCY: """
"""""",""" Actual Size: """,""" TCY: """
"""""","""Graph Visualizer""","""Otu"""
"""""","""m_controlsPanel""",""""""
"""""","""Naive Layout""","""iC[uȃCAEg"""
"""""","""Priority Layout""","""D挠CAEg"""
"""""","""Top Down""","""gbv_E"""
"""""","""Bottom Up""","""ɒɒBĂB"""
"""""","""With Edge Concentration""","""̏W"""
"""""","""Layout Type""","""CAEg^Cv"""
"""""","""Layout Method""","""CAEg\bh"""
"""""","""layoutCompleteListener to be remove not present""","""ǂȃv[gOȂƂłlayoutCompleteListener"""
"""""","""Minimizing Crossings: Pass""","""_ŏɂ܂: pX"""
"""""","""\nCrossings at the end ""","""I\nCrossings"""
"""""","""Laying out vertices""","""L܂B"""
"""""","""Layout Complete""","""CAEgSłB"""
"""""","""Before.............""","""ȑOc"""
"""""","""origNodesSize: """,""""""
"""""","""After..............""","""c"""
"""""","""graphMatrix""",""""""
"""""","""The ""","""The"""
"""""",""" nodes are: """,""" m[h͈ȉ̒ʂłB """
"""""","""\nThe ""","""\nThe"""
"""""",""" edges are: """,""" ͈ȉ̒ʂłB """
"""""","""Removing Cycles""","""O͏z܂B"""
"""""","""Assigning levels to nodes""","""xm[hɊ蓖Ă܂B"""
"""""","""Removing gaps by adding dummy vertices""","""_~[̓邱ƂɂāAMbv菜܂B"""
"""""","""Processing node ""","""m[h"""
"""""","""tempnode will be true""","""tempnode͖{ɂȂł傤B"""
"""""","""breaking from loop""","""ւƁA܂B"""
"""""","""Adding dummy ""","""_~[܂B"""
"""""",""" tempnode """,""" tempnode"""
"""""",""" len """,""" len"""
"""""","""modifying ""","""ύX"""
"""""","""Error. Didn't find element ""","""B vf܂łB"""
"""""",""" in level. Inspect code for """,""" xŁB R[h_܂B"""
"""""","""*****************Processing level ""","""*****************x"""
"""""","""Removing from upper: ""","""㑤AO܂: """
"""""","""levels[i][uidx]: ""","""xi uidx: """
"""""",""" upper.first: """,""" o܍ŏ: """
"""""","""Adding to lower: ""","""낷߂ɁA܂: """
"""""",""" first's n is: """,""" 1ԖڂɂnƂƂł: """
"""""","""Removing from lower: ""","""ႭOA: """
"""""","""temp: ""","""Վ: """
"""""",""" lastOcrnce: """,""""""
"""""",""" temp.n: """,""""""
"""""",""" lastOcrnce.n: """,""""""
"""""","""levels[i+1][lidx]: ""","""xi+1lidx: """
"""""",""" which is: """,""" ǂ͈ȉ̒ʂł邩B """
"""""",""" lower.first: """,""" . 1Ԗڂ낵Ă: """
"""""","""Adding to upper: ""","""㑤ɉ܂: """
"""""",""" which is : """,""" ǂ͈ȉ̒ʂł邩B """
"""""",""" from node: """,""" m[h: """
"""""",""" first's value: """,""" ܂ŏɁAl܂: """
"""""","""Sum at the end is: ""","""I̍v͈ȉ̒ʂłB """
"""""","""\nFound double ""","""\nFound͔{܂B"""
"""""","""\nReversing ""","""\nReversing"""
"""""","""\nCrossings after phaseIIU: ""","""phaseIIǓ\nCrossings: """
"""""","""\nCrossings before PHaseIU: ""","""PHaseIȖO\nCrossings: """
"""""","""Crossings before PHaseID: ""","""PHaseID̑Ǒ_: """
"""""","""\nCrossings before PHaseIIU: ""","""PHaseIIȖO\nCrossings: """
"""""","""\nCrossings before PHaseIID: ""","""PHaseIID̑O\nCrossings: """
"""""","""\nCrossings after phaseIID: ""","""phaseIIĎ\nCrossings: """
"""""","""In ID Level""","""IDx"""
"""""","""After sorting""","""\[eBǑ"""
"""""","""Col""",""""""
"""""","""In IU Level""","""IUx"""
"""""","""After sorting\n\t""","""\[eBO\n\ť"""
"""""","""Row""","""ʂ"""
"""""","""\n\tNodes ""","""\n\tNodes"""
"""""","""\nCrossings: """,""""""
"""""","""getting into phase IID""","""tF[YIIDɓ܂B"""
"""""","""Crossings after PhaseID of phaseIID, ""","""phaseIIDPhaseIĎ̌_"""
"""""","""in iteration ""","""JԂ"""
"""""","""Crossings temp:""","""_͔hЈƂē܂:"""
"""""",""" graph:""",""" Ot:"""
"""""","""Crossings after PhaseIU of phaseIID, in""","""phaseIIĎ_PhaseIU"""
"""""",""" iteration """,""" JԂ"""
"""""","""Getting into phaseIIU""","""phaseIIUɓ܂B"""
"""""","""Crossings before begining of iteration: ""","""JԂbeginingǑ_: """
"""""","""Interchanging: ""","""܂: """
"""""",""" at level """,""" x"""
"""""","""Crossings after PhaseIU of PhaseIIU, in ""","""PhaseIIǓ_PhaseIU"""
"""""","""Crossings temp: ""","""_͔hЈƂē܂: """
"""""",""" Crossings levels: """,""" _x: """
"""""","""Crossings after PhaseID of phaseIIU, in ""","""phaseIIǓ_PhaseID"""
"""""","""iteration ""","""JԂ"""
"""""",""", levels: """,""", x: """
"""""",""" temp: """,""" Վ: """
"""""","""\nAt the end i: ""","""\͏IinAt܂: """
"""""",""" levels.length: """,""""""
"""""","""uBC Result: ""","""uBC͌ʂɂȂ܂: """
"""""","""********Going from 2 to n********""","""********2?n܂ōs܂B********"""
"""""","""********Going from n-1 to 1********""","""********n-1A1܂ōs܂B********"""
"""""",""" lConnectivity: """,""""""
"""""",""" lBC: """,""""""
"""""","""********Going from 2 to n again********""","""********Ă2?n܂ōs܂B********"""
"""""","""Level: ""","""x: """
"""""",""" Node: """,""" m[h: """
"""""",""" uConnectivity: """,""""""
"""""",""" uBC: """,""""""
"""""",""" position: """,""" ʒu: """
"""""","""Moving """,""""""
"""""","""Moving main ""","""C𓮂܂B"""
"""""",""" from """,""" from"""
"""""","""Error shouldn't be in here. Check MyList code""","""肪ɂׂł͂܂B MyListR[h`FbNĂB"""
"""""","""element ""","""vf"""
"""""","""not present in the list""","""Xg̒ɑ݂Ă܂B"""
"""""","""Simple CLI""","""R}hC"""
"""""","""Experimenter""",""""""
"""""","""KnowledgeFlow""",""""""
"""""","""Weka GUI Chooser""","""Weka GUI j["""
"""""","""GUI""",""""""
"""""","""Weka, a native bird of New Zealand""","""Weka Aj[W[hY̒"""
"""""","""Waikato Environment for""","""Waikato Environment for"""
"""""","""Knowledge Analysis""","""Knowledge Analysis"""
"""""","""Version ""","""o[W"""
"""""","""(c) 1999 - 2005""",""""""
"""""","""University of Waikato""","""CJgw"""
"""""","""New Zealand""","""j[W[h"""
"""""","""Couldn't start SimpleCLI!""","""R}hCn邱Ƃł܂ł!"""
"""""","""Weka Explorer""","""Weka GNXv[["""
"""""","""Weka Experiment Environment""","""Weka """
"""""","""Weka KnowledgeFlow Environment""","""Weka KnowledgeFlow"""
"""""","""before sleeping""","""̑O"""
"""""","""\ndisplayed message:""","""\nbZ[W̕\:"""
"""""","""\nexiting...""","""\nIc"""
"""""","""synchronized""","""܂"""
"""""","""delim: """,""""""
"""""","""The given property is not in""","""Ȃt^"""
"""""","""hierachy structure with seperators!""","""seperators!hierachy\!"""
"""""","""Position out of range or leaf reached""","""͈͂ẗʒuɒB܂B"""
"""""","""node1.node1_1.node1_1_1.node1_1_1_1, ""","""node1.node1_1.node1_1_1.node1_1_1_1"""
"""""","""node1.node1_1.node1_1_1.node1_1_1_2, ""","""node1.node1_1.node1_1_1.node1_1_1_2"""
"""""","""node1.node1_1.node1_1_1.node1_1_1_3, ""","""node1.node1_1.node1_1_1.node1_1_1_3"""
"""""","""node1.node1_1.node1_1_2.node1_1_2_1, ""","""node1.node1_1.node1_1_2.node1_1_2_1"""
"""""","""node1.node1_1.node1_1_3.node1_1_3_1, ""","""node1.node1_1.node1_1_3.node1_1_3_1"""
"""""","""node1.node1_2.node1_2_1.node1_2_1_1, ""","""node1.node1_2.node1_2_1.node1_2_1_1"""
"""""","""node1.node1_2.node1_2_3.node1_2_3_1, ""","""node1.node1_2.node1_2_3.node1_2_3_1"""
"""""","""node1.node1_3.node1_3_3.node1_3_3_1, ""","""node1.node1_3.node1_3_3.node1_3_3_1"""
"""""","""node1.node1_3.node1_3_3.node1_3_3_2, ""","""node1.node1_3.node1_3_3.node1_3_3_2"""
"""""","""seperator: """,""""""
"""""","""depth: ""","""[: """
"""""","""The tree:\n\n""",""": \n\n"""
"""""","""goto: """,""""""
"""""","""go down(wrong): ""","""Ă(ԈĂ): """
"""""","""Stay still? ""","""܂A؍݂Ă܂?"""
"""""","""go to child: ""","""qɍsĂ: """
"""""","""node1_2_1_1""",""""""
"""""","""parent: ""","""e: """
"""""","""context: """,""": """
"""""","""After gotoRoot. leaf? ""","""gotoRootť?"""
"""""","""Go down(correct): ""","""Ă(C܂): """
"""""",""" value: """,""" l: """
"""""",""" level: """,""" x: """
"""""",""" leaf? """,""" t?"""
"""""",""" root? """,""" Â܂?"""
"""""","""value: ""","""l: """
"""""","""level: ""","""x: """
"""""","""children ""","""q"""
"""""","""real value: """,""": """
"""""","""(level: ""","""(x:"""
"""""","""Another way to go to root:""","""Âɍsʂ̕@:"""
"""""","""node1""",""""""
"""""","""None""","""Ȃ"""
"""""","""Instances Panel""","""CX^Xpl"""
"""""","""Relation""","""֌W"""
"""""","""invalid col ""","""̗"""
"""""","""Select items""","""ڂIĂB"""
"""""","""one""","""1"""
"""""","""two""","""2"""
"""""","""three""","""3"""
"""""","""four""","""4"""
"""""","""five""","""5"""
"""""","""Fields Selected""","""Iꂽ"""
"""""","""Status""",""""""
"""""","""Log""","""O"""
"""""","""Memory information""",""""""
"""""","""Memory (free/total/max.) in bytes: ""","""oCgŕ\郁(邩AvA܂͍őɂĂB): """
"""""","""Run garbage collector""","""ݎWlԂőĂB"""
"""""","""Running garbage collector""","""sݎWl"""
"""""","""Log Panel""","""Opl"""
"""""","""Welcome to the generic log panel!""","""ʓIȃOplւ悤!"""
"""""","""Hi there""","""₠"""
"""""","""Funky chickens""","""ςȌ{"""
"""""","""LookAndFeel: Could not read a LookAndFeel configuration file.\n""","""LookAndFeel: LookAndFeel\t@C\nǂނƂł܂łB"""
"""""","""LookAndFeel""",""""""
"""""","""Theme""","""e[}"""
"""""","""Click to edit properties for this object""","""NbNāÃIuWFNĝ߂ɓҏWĂB"""
"""""","""Select""","""I"""
"""""","""Select a property""","""IĂB"""
"""""","""PropertySelectorDialog: Couldn't introspect""","""PropertySelectorDialog: Ȃ邱Ƃł܂łB"""
"""""","""Property Selected""","""Iꂽ"""
"""""","""Cancelled""","""܂B"""
"""""","""PropertySheet: Couldn't introspect""","""PropertySheet: Ȃ邱Ƃł܂łB"""
"""""","""globalInfo""",""""""
"""""","""NAME\n""","""O\n"""
"""""","""SYNOPSIS\n""","""\\n"""
"""""","""More""",""""""
"""""","""More information about ""","""悻ڂ"""
"""""","""About""",""""""
"""""","""Warning: Can't find public property editor""","""x: ̃vpeBGfB^邱Ƃł܂B"""
"""""",""" for property """"",""" Auv"""
"""""",""""" (class """"","""uu(uvv𕪗ނĂB"""
"""""",""""").  Skipping.""","""""). XLbvB"""
"""""","""java.""","""javaB"""
"""""",""""" has null initial value.  Skipping.""","""uuk̒lĂAv XLbvB"""
"""""","""TipText""",""""""
"""""","""OPTIONS\n""","""IvV\n"""
"""""","""Warning: Property """"","""x: Auv"""
"""""",""""" has non-displayabale editor.  Skipping.""","""uudisplayabaleGfB^ĂAv XLbvB"""
"""""",""" ; exception on target: """,""" ; ڕW̗O: """
"""""","""Skipping property ""","""XLbv܂B"""
"""""",""" ; exception: """,""" ; O: """
"""""","""No editable properties""","""ҏW\ȍڂ܂"""
"""""","""Information""",""""""
"""""","""wasModified""","""wasModified܂B"""
"""""","""WARNING: Vetoed; reason is: ""","""x: ۂ܂; R͈ȉ̒ʂłB """
"""""",""" while updating """,""" Abvf[g߂ĂB"""
"""""","""error""",""""""
"""""","""Unexpected exception while updating ""","""\ȂO̓Abvf[g߂܂B"""
"""""","""Trying to repaint the property canvas""","""̃LoXɓhւ悤Ƃ܂B"""
"""""","""Trying to repaint ""","""hւs"""
"""""","""null""",""""""
"""""","""Result history""","""ʂ̗"""
"""""","""Weka Explorer: Classifier""","""Weka GNXv[[: NVt@CA"""
"""""","""Nothing to see here""","""邽߂ɉłȂ"""
"""""","""blah1""",""""""
"""""","""Nothing to see here1""","""here1邽߂ɉłȂ"""
"""""","""blah2""",""""""
"""""","""Nothing to see here2""","""here2邽߂ɉłȂ"""
"""""","""blah3""",""""""
"""""","""Nothing to see here3""","""here3邽߂ɉłȂ"""
"""""","""Append""","""ǉ"""
"""""","""Overwrite""","""㏑"""
"""""","""Choose new name""","""VOIł"""
"""""","""File exists""","""t@C݂͑Ă܂"""
"""""","""File query""","""t@C"""
"""""","""Appending to file...""","""t@Cɒǉc"""
"""""","""Saving to file...""","""t@Cɕۑc"""
"""""","""SaveBuffer test""","""SaveBuffereXg"""
"""""","""A bit of test text""","""̃eXgeLXg"""
"""""","""new SelectedTag(""","""VSelectedTagA("""
"""""","""new Tag(""","""V^O("""
"""""","""---Registering Weka Editors---""","""---Weka GfB^o^---"""
"""""","""First option""","""1Ԗڂ̃IvV"""
"""""","""Second option""","""2Ԗڂ̃IvV"""
"""""","""Third option""","""3Ԗڂ̃IvV"""
"""""","""Fourth option""","""4Ԗڂ̃IvV"""
"""""","""Fifth option""","""5Ԗڂ̃IvV"""
"""""","""Open file...""","""t@CJc"""
"""""","""Open URL...""","""URLJc"""
"""""","""Open a set of instances from a file""","""t@C1̃f[^ZbgJ"""
"""""","""Open a set of instances from a URL""","""URL1̃f[^ZbgJ"""
"""""","""Enter the source URL""","""\[XURL"""
"""""","""Problem with URL:\n""","""URL̖: \n"""
"""""","""Can't load at this time,\n""","""݁C[hł܂D\n"""
"""""","""currently busy with other IO""","""IOƋĂ܂D"""
"""""","""Couldn't read from file:\n""","""t@C̓ǂݍ݂ł܂ł: \n"""
"""""","""Couldn't read from URL:\n""","""URLǂݍ݂ł܂ł: \n"""
"""""","""Load Instances""",""""""
"""""","""main(String[]) method of """,""""""
"""""",""" is not public and static.""",""""""
"""""","""[Run exception] ""","""[s̗O]"""
"""""","""South""",""""""
"""""","""Redirecting System.out""","""System.out܂B"""
"""""","""Redirecting System.err""","""System.err܂B"""
"""""","""\nWelcome to the WEKA SimpleCLI\n\n""","""\nWeka SimpleCLIւ悤\n\n"""
"""""","""Enter commands in the textfield at the bottom of \n""","""R}hEBhẼeLXg̈ɓ͂ĂD\n"""
"""""","""the window. Use the up and down arrows to move \n""","""㉺̖L[ɂ\n"""
"""""","""through previous commands.\n\n""","""ÕR}hĂяoƂł܂D\n\n"""
"""""","""No class name given""","""NX܂"""
"""""","""An object is already running, use ""break""""","""IuWFNg͂łɎsĂ܂D""break""悤ĂD"""
"""""",""" to interrupt it.""",""" 𒆒f邽߂ɁD"""
"""""","""<classname>""",""""""
"""""","""[Interrupt...]""","""fc"""
"""""","""Nothing is currently running.""","""݁Cs̃Wu͂܂D"""
"""""","""[Kill...]""","""cEĂB"""
"""""","""help""","""wv"""
"""""","""java""",""""""
"""""","""java <classname> <args>\n\n""","""java(<classname>)<args>\n\n"""
"""""","""Starts the main method of <classname> with ""","""<classname>Ŏw肳ꂽNXmain\bhJn܂D"""
"""""","""the supplied command line arguments (if any).\n""","""(Ȃ)\n"""
"""""","""The command is started in a separate thread, ""","""R}h͕ʂ̃XbhŎn߂܂D"""
"""""","""and may be interrupted with the ""break""\n""","""āC""break""ɂăR}h(DӓI)fł܂D\n"""
"""""","""command (friendly), or killed with the ""kill"" ""","""ꂩC""kill""ɂăR}h"""
"""""","""command (unfriendly).\n""","""I܂D\n"""
"""""","""break""",""""""
"""""","""break\n\n""","""f\n\n"""
"""""","""Attempts to nicely interrupt the running job, ""","""gpƎs̃Wu܂fł܂D"""
"""""","""if any. If this doesn't respond in an\n""","""CŔȂꍇ\n"""
"""""","""acceptable time, use ""kill"".\n""","""""kill""gpĂD\n"""
"""""","""kill""",""""""
"""""","""kill\n\n""","""I\n\n"""
"""""","""Kills the running job, if any. You should only ""","""gpꍇCs̃WuI܂D ɁC"""
"""""","""use this if the job doesn't respond to\n""","""""break""ȂƂɂp܂D\n"""
"""""","""""break"".\n""","""\n"""
"""""","""cls""",""""""
"""""","""cls\n\n""",""""""
"""""","""Clears the output area.\n""","""o͗̈̃NA\n"""
"""""","""exit""","""I"""
"""""","""exit\n\n""","""I\n\n"""
"""""","""Exits the SimpleCLI program.\n""","""SimpleCLI̖ŏI\n"""
"""""","""Command must be one of:\n""","""R}h͂ꂼ: \n"""
"""""","""\tjava <classname> <args>\n""","""\tjava <NX> <>"""
"""""","""\tbreak\n""",""""""
"""""","""\tkill\n""",""""""
"""""","""\tcls\n""",""""""
"""""","""\texit\n""",""""""
"""""","""\thelp <command>\n""","""\thelp <R}h>\n"""
"""""","""window closed""","""͕܂D"""
"""""","""Failed to invoke method: ""","""\bh̎sɎs: """
"""""","""main""",""""""
"""""","""Failed to invoke main method""","""main\bh̎sɎs"""
"""""","""no instances""","""f[^܂"""
"""""","""InstanceCounter::instanceProduced() - End of instance batch""","""InstanceCounter:A:instanceProduced()--CX^Xob`̏I"""
"""""","""InstanceCounter::instanceProduced() - unknown event type""","""InstanceCounter:A:instanceProduced()--m̃Cxg^Cv"""
"""""","""InstanceCounter::instanceProduced() - Unknown source object type""","""InstanceCounter:A:instanceProduced()--m̃\[XIuWFNgE^Cv"""
"""""","""No input instance format defined""","""`Ȃ̓CX^XS"""
"""""","""No output instance format defined""","""`Ȃo̓CX^XS"""
"""""","""Problem: notifyInstanceProduced() was\n""",""": notifyInstanceProduced()\nłB"""
"""""","""called with INSTANCE_AVAILABLE, but output()\n""","""AINSTANCE_AVAILABLEAo()\nŁAĂ΂܂B"""
"""""","""threw an exception: ""","""O𓊂܂: """
"""""","""::firstInstanceProduced() - Format available""","""::firstInstanceProduced()--p\Ȍ`"""
"""""","""::firstInstanceProduced() - Instance available""","""::firstInstanceProduced()--p\ȃCX^X"""
"""""","""::firstInstanceProduced() - End of instance batch""","""::firstInstanceProduced()--CX^Xob`̏I"""
"""""","""::firstInstanceProduced() - unknown event type""","""::firstInstanceProduced()--m̃Cxg^Cv"""
"""""","""::firstInstanceProduced() - Unknown source object type""","""::firstInstanceProduced()--m̃\[XIuWFNgE^Cv"""
"""""","""::secondInstanceProduced() - Input received from""","""::secondInstanceProduced()--󂯎ĂԂŁA͂܂B"""
"""""",""" second stream before first stream finished""",""" ŏ̗ꂪIO2Ԗڂ̗"""
"""""","""::secondInstanceProduced() - Format available""","""::secondInstanceProduced()--p\Ȍ`"""
"""""","""::secondInstanceProduced() - incompatible instance streams""","""::secondInstanceProduced()--ȂCX^XXg["""
"""""","""::secondInstanceProduced() - Instance available""","""::secondInstanceProduced()--p\ȃCX^X"""
"""""","""::secondInstanceProduced() - End of instance batch""","""::secondInstanceProduced()--CX^Xob`̏I"""
"""""","""::secondInstanceProduced() - unknown event type""","""::secondInstanceProduced()--m̃Cxg^Cv"""
"""""","""::secondInstanceProduced() - Unknown source object type""","""::secondInstanceProduced()--m̃\[XIuWFNgE^Cv"""
"""""","""Stop""","""~"""
"""""",""" - Instances opened from: """,""" - ͈ȉJ܂B """
"""""",""" - read instance""",""" - CX^Xǂ݂܂B"""
"""""","""Start""","""Jn"""
"""""","""West""",""""""
"""""","""No output format defined.""","""͏o͒`܂łB"""
"""""",""" instances""",""" CX^X"""
"""""","""InstanceSavePanel::inputFormat() - written header""","""InstanceSavePanel:A:inputFormat()--ꂽwb_["""
"""""","""InstanceSavePanel::inputFormat(): ""","""InstanceSavePanel:A:inputFormat(): """
"""""","""0 instances""","""0̗"""
"""""","""East""",""""""
"""""","""InstanceSavePanel::instanceProduced() - unknown event type""","""InstanceSavePanel:A:instanceProduced()--m̃Cxg^Cv"""
"""""","""InstanceSavePanel::instanceProduced() - Unknown source object type""","""InstanceSavePanel:A:instanceProduced()--m̃\[XIuWFNgE^Cv"""
"""""","""Center""",""""""
"""""",""" - unknown event type""",""" - m̃Cxg^Cv"""
"""""",""" - Unknown source object type""",""" - m̃\[XIuWFNgE^Cv"""
"""""","""yyyy.MM.dd hh:mm:ss""",""""""
"""""","""LOG ""","""O"""
"""""","""STATUS: """,""": """
"""""","""rowsAdded""","""rowsAdded܂B"""
"""""","""Sorter: tableChanged""","""Iʋ@: tableChanged܂B"""
"""""","""Sorter not informed of a change in model.""","""Iʋ@̓fɂωm点܂łB"""
"""""","""Compares: ""","""r܂: """
"""""","""indexes""","""CfbNX"""
"""""","""Sorting ...""","""񒆁c"""
"""""","""snow""",""""""
"""""","""ghostwhite""",""""""
"""""","""whitesmoke""",""""""
"""""","""gainsboro""",""""""
"""""","""floralwhite""",""""""
"""""","""oldlace""",""""""
"""""","""linen""",""""""
"""""","""antiquewhite""",""""""
"""""","""papayawhip""",""""""
"""""","""blanchedalmond""",""""""
"""""","""bisque""",""""""
"""""","""peachpuff""",""""""
"""""","""navajowhite""",""""""
"""""","""moccasin""",""""""
"""""","""cornsilk""",""""""
"""""","""ivory""",""""""
"""""","""lemonchiffon""",""""""
"""""","""seashell""",""""""
"""""","""honeydew""",""""""
"""""","""mintcream""",""""""
"""""","""azure""",""""""
"""""","""aliceblue""",""""""
"""""","""lavender""",""""""
"""""","""lavenderblush""",""""""
"""""","""mistyrose""",""""""
"""""","""darkslategray""",""""""
"""""","""dimgray""",""""""
"""""","""slategray""",""""""
"""""","""lightslategray""",""""""
"""""","""lightgray""",""""""
"""""","""midnightblue""",""""""
"""""","""navy""",""""""
"""""","""cornflowerblue""",""""""
"""""","""darkslateblue""",""""""
"""""","""slateblue""",""""""
"""""","""mediumslateblue""",""""""
"""""","""lightslateblue""",""""""
"""""","""mediumblue""",""""""
"""""","""royalblue""",""""""
"""""","""dodgerblue""",""""""
"""""","""deepskyblue""",""""""
"""""","""skyblue""",""""""
"""""","""lightskyblue""",""""""
"""""","""steelblue""",""""""
"""""","""lightsteelblue""",""""""
"""""","""lightblue""",""""""
"""""","""powderblue""",""""""
"""""","""paleturquoise""",""""""
"""""","""darkturquoise""",""""""
"""""","""mediumturquoise""",""""""
"""""","""turquoise""",""""""
"""""","""lightcyan""",""""""
"""""","""cadetblue""",""""""
"""""","""mediumaquamarine""",""""""
"""""","""aquamarine""",""""""
"""""","""darkgreen""",""""""
"""""","""darkolivegreen""",""""""
"""""","""darkseagreen""",""""""
"""""","""seagreen""",""""""
"""""","""mediumseagreen""",""""""
"""""","""lightseagreen""",""""""
"""""","""palegreen""",""""""
"""""","""springgreen""",""""""
"""""","""lawngreen""",""""""
"""""","""chartreuse""",""""""
"""""","""mediumspringgreen""",""""""
"""""","""greenyellow""",""""""
"""""","""limegreen""",""""""
"""""","""yellowgreen""",""""""
"""""","""forestgreen""",""""""
"""""","""olivedrab""",""""""
"""""","""darkkhaki""",""""""
"""""","""khaki""",""""""
"""""","""palegoldenrod""",""""""
"""""","""lightgoldenrodyellow""",""""""
"""""","""lightyellow""",""""""
"""""","""gold""",""""""
"""""","""lightgoldenrod""",""""""
"""""","""goldenrod""",""""""
"""""","""darkgoldenrod""",""""""
"""""","""rosybrown""",""""""
"""""","""indianred""",""""""
"""""","""saddlebrown""",""""""
"""""","""sienna""",""""""
"""""","""peru""",""""""
"""""","""burlywood""",""""""
"""""","""beige""",""""""
"""""","""wheat""",""""""
"""""","""sandybrown""",""""""
"""""","""tan""",""""""
"""""","""chocolate""",""""""
"""""","""firebrick""",""""""
"""""","""brown""",""""""
"""""","""darksalmon""",""""""
"""""","""salmon""",""""""
"""""","""lightsalmon""",""""""
"""""","""darkorange""",""""""
"""""","""coral""",""""""
"""""","""lightcoral""",""""""
"""""","""tomato""",""""""
"""""","""orangered""",""""""
"""""","""hotpink""",""""""
"""""","""deeppink""",""""""
"""""","""lightpink""",""""""
"""""","""palevioletred""",""""""
"""""","""maroon""",""""""
"""""","""mediumvioletred""",""""""
"""""","""violetred""",""""""
"""""","""violet""",""""""
"""""","""plum""",""""""
"""""","""orchid""",""""""
"""""","""mediumorchid""",""""""
"""""","""darkorchid""",""""""
"""""","""darkviolet""",""""""
"""""","""blueviolet""",""""""
"""""","""purple""",""""""
"""""","""mediumpurple""",""""""
"""""","""thistle""",""""""
"""""","""snow1""",""""""
"""""","""snow2""",""""""
"""""","""snow3""",""""""
"""""","""snow4""",""""""
"""""","""seashell1""",""""""
"""""","""seashell2""",""""""
"""""","""seashell3""",""""""
"""""","""seashell4""",""""""
"""""","""antiquewhite1""",""""""
"""""","""antiquewhite2""",""""""
"""""","""antiquewhite3""",""""""
"""""","""antiquewhite4""",""""""
"""""","""bisque1""",""""""
"""""","""bisque2""",""""""
"""""","""bisque3""",""""""
"""""","""bisque4""",""""""
"""""","""peachpuff1""",""""""
"""""","""peachpuff2""",""""""
"""""","""peachpuff3""",""""""
"""""","""peachpuff4""",""""""
"""""","""navajowhite1""",""""""
"""""","""navajowhite2""",""""""
"""""","""navajowhite3""",""""""
"""""","""navajowhite4""",""""""
"""""","""lemonchiffon1""",""""""
"""""","""lemonchiffon2""",""""""
"""""","""lemonchiffon3""",""""""
"""""","""lemonchiffon4""",""""""
"""""","""cornsilk1""",""""""
"""""","""cornsilk2""",""""""
"""""","""cornsilk3""",""""""
"""""","""cornsilk4""",""""""
"""""","""ivory1""",""""""
"""""","""ivory2""",""""""
"""""","""ivory3""",""""""
"""""","""ivory4""",""""""
"""""","""honeydew1""",""""""
"""""","""honeydew2""",""""""
"""""","""honeydew3""",""""""
"""""","""honeydew4""",""""""
"""""","""lavenderblush1""",""""""
"""""","""lavenderblush2""",""""""
"""""","""lavenderblush3""",""""""
"""""","""lavenderblush4""",""""""
"""""","""mistyrose1""",""""""
"""""","""mistyrose2""",""""""
"""""","""mistyrose3""",""""""
"""""","""mistyrose4""",""""""
"""""","""azure1""",""""""
"""""","""azure2""",""""""
"""""","""azure3""",""""""
"""""","""azure4""",""""""
"""""","""slateblue1""",""""""
"""""","""slateblue2""",""""""
"""""","""slateblue3""",""""""
"""""","""slateblue4""",""""""
"""""","""royalblue1""",""""""
"""""","""royalblue2""",""""""
"""""","""royalblue3""",""""""
"""""","""royalblue4""",""""""
"""""","""blue1""",""""""
"""""","""blue2""",""""""
"""""","""blue3""",""""""
"""""","""blue4""",""""""
"""""","""dodgerblue1""",""""""
"""""","""dodgerblue2""",""""""
"""""","""dodgerblue3""",""""""
"""""","""dodgerblue4""",""""""
"""""","""steelblue1""",""""""
"""""","""steelblue2""",""""""
"""""","""steelblue3""",""""""
"""""","""steelblue4""",""""""
"""""","""deepskyblue1""",""""""
"""""","""deepskyblue2""",""""""
"""""","""deepskyblue3""",""""""
"""""","""deepskyblue4""",""""""
"""""","""skyblue1""",""""""
"""""","""skyblue2""",""""""
"""""","""skyblue3""",""""""
"""""","""skyblue4""",""""""
"""""","""lightskyblue1""",""""""
"""""","""lightskyblue2""",""""""
"""""","""lightskyblue3""",""""""
"""""","""lightskyblue4""",""""""
"""""","""slategray1""",""""""
"""""","""slategray2""",""""""
"""""","""slategray3""",""""""
"""""","""slategray4""",""""""
"""""","""lightsteelblue1""",""""""
"""""","""lightsteelblue2""",""""""
"""""","""lightsteelblue3""",""""""
"""""","""lightsteelblue4""",""""""
"""""","""lightblue1""",""""""
"""""","""lightblue2""",""""""
"""""","""lightblue3""",""""""
"""""","""lightblue4""",""""""
"""""","""lightcyan1""",""""""
"""""","""lightcyan2""",""""""
"""""","""lightcyan3""",""""""
"""""","""lightcyan4""",""""""
"""""","""paleturquoise1""",""""""
"""""","""paleturquoise2""",""""""
"""""","""paleturquoise3""",""""""
"""""","""paleturquoise4""",""""""
"""""","""cadetblue1""",""""""
"""""","""cadetblue2""",""""""
"""""","""cadetblue3""",""""""
"""""","""cadetblue4""",""""""
"""""","""turquoise1""",""""""
"""""","""turquoise2""",""""""
"""""","""turquoise3""",""""""
"""""","""turquoise4""",""""""
"""""","""cyan1""",""""""
"""""","""cyan2""",""""""
"""""","""cyan3""",""""""
"""""","""cyan4""",""""""
"""""","""darkslategray1""",""""""
"""""","""darkslategray2""",""""""
"""""","""darkslategray3""",""""""
"""""","""darkslategray4""",""""""
"""""","""aquamarine1""",""""""
"""""","""aquamarine2""",""""""
"""""","""aquamarine3""",""""""
"""""","""aquamarine4""",""""""
"""""","""darkseagreen1""",""""""
"""""","""darkseagreen2""",""""""
"""""","""darkseagreen3""",""""""
"""""","""darkseagreen4""",""""""
"""""","""seagreen1""",""""""
"""""","""seagreen2""",""""""
"""""","""seagreen3""",""""""
"""""","""seagreen4""",""""""
"""""","""palegreen1""",""""""
"""""","""palegreen2""",""""""
"""""","""palegreen3""",""""""
"""""","""palegreen4""",""""""
"""""","""springgreen1""",""""""
"""""","""springgreen2""",""""""
"""""","""springgreen3""",""""""
"""""","""springgreen4""",""""""
"""""","""green1""",""""""
"""""","""green2""",""""""
"""""","""green3""",""""""
"""""","""green4""",""""""
"""""","""chartreuse1""",""""""
"""""","""chartreuse2""",""""""
"""""","""chartreuse3""",""""""
"""""","""chartreuse4""",""""""
"""""","""olivedrab1""",""""""
"""""","""olivedrab2""",""""""
"""""","""olivedrab3""",""""""
"""""","""olivedrab4""",""""""
"""""","""darkolivegreen1""",""""""
"""""","""darkolivegreen2""",""""""
"""""","""darkolivegreen3""",""""""
"""""","""darkolivegreen4""",""""""
"""""","""khaki1""",""""""
"""""","""khaki2""",""""""
"""""","""khaki3""",""""""
"""""","""khaki4""",""""""
"""""","""lightgoldenrod1""",""""""
"""""","""lightgoldenrod2""",""""""
"""""","""lightgoldenrod3""",""""""
"""""","""lightgoldenrod4""",""""""
"""""","""lightyellow1""",""""""
"""""","""lightyellow2""",""""""
"""""","""lightyellow3""",""""""
"""""","""lightyellow4""",""""""
"""""","""yellow1""",""""""
"""""","""yellow2""",""""""
"""""","""yellow3""",""""""
"""""","""yellow4""",""""""
"""""","""gold1""",""""""
"""""","""gold2""",""""""
"""""","""gold3""",""""""
"""""","""gold4""",""""""
"""""","""goldenrod1""",""""""
"""""","""goldenrod2""",""""""
"""""","""goldenrod3""",""""""
"""""","""goldenrod4""",""""""
"""""","""darkgoldenrod1""",""""""
"""""","""darkgoldenrod2""",""""""
"""""","""darkgoldenrod3""",""""""
"""""","""darkgoldenrod4""",""""""
"""""","""rosybrown1""",""""""
"""""","""rosybrown2""",""""""
"""""","""rosybrown3""",""""""
"""""","""rosybrown4""",""""""
"""""","""indianred1""",""""""
"""""","""indianred2""",""""""
"""""","""indianred3""",""""""
"""""","""indianred4""",""""""
"""""","""sienna1""",""""""
"""""","""sienna2""",""""""
"""""","""sienna3""",""""""
"""""","""sienna4""",""""""
"""""","""burlywood1""",""""""
"""""","""burlywood2""",""""""
"""""","""burlywood3""",""""""
"""""","""burlywood4""",""""""
"""""","""wheat1""",""""""
"""""","""wheat2""",""""""
"""""","""wheat3""",""""""
"""""","""wheat4""",""""""
"""""","""tan1""",""""""
"""""","""tan2""",""""""
"""""","""tan3""",""""""
"""""","""tan4""",""""""
"""""","""chocolate1""",""""""
"""""","""chocolate2""",""""""
"""""","""chocolate3""",""""""
"""""","""chocolate4""",""""""
"""""","""firebrick1""",""""""
"""""","""firebrick2""",""""""
"""""","""firebrick3""",""""""
"""""","""firebrick4""",""""""
"""""","""brown1""",""""""
"""""","""brown2""",""""""
"""""","""brown3""",""""""
"""""","""brown4""",""""""
"""""","""salmon1""",""""""
"""""","""salmon2""",""""""
"""""","""salmon3""",""""""
"""""","""salmon4""",""""""
"""""","""lightsalmon1""",""""""
"""""","""lightsalmon2""",""""""
"""""","""lightsalmon3""",""""""
"""""","""lightsalmon4""",""""""
"""""","""orange1""",""""""
"""""","""orange2""",""""""
"""""","""orange3""",""""""
"""""","""orange4""",""""""
"""""","""darkorange1""",""""""
"""""","""darkorange2""",""""""
"""""","""darkorange3""",""""""
"""""","""darkorange4""",""""""
"""""","""coral1""",""""""
"""""","""coral2""",""""""
"""""","""coral3""",""""""
"""""","""coral4""",""""""
"""""","""tomato1""",""""""
"""""","""tomato2""",""""""
"""""","""tomato3""",""""""
"""""","""tomato4""",""""""
"""""","""orangered1""",""""""
"""""","""orangered2""",""""""
"""""","""orangered3""",""""""
"""""","""orangered4""",""""""
"""""","""red1""",""""""
"""""","""red2""",""""""
"""""","""red3""",""""""
"""""","""red4""",""""""
"""""","""deeppink1""",""""""
"""""","""deeppink2""",""""""
"""""","""deeppink3""",""""""
"""""","""deeppink4""",""""""
"""""","""hotpink1""",""""""
"""""","""hotpink2""",""""""
"""""","""hotpink3""",""""""
"""""","""hotpink4""",""""""
"""""","""pink1""",""""""
"""""","""pink2""",""""""
"""""","""pink3""",""""""
"""""","""pink4""",""""""
"""""","""lightpink1""",""""""
"""""","""lightpink2""",""""""
"""""","""lightpink3""",""""""
"""""","""lightpink4""",""""""
"""""","""palevioletred1""",""""""
"""""","""palevioletred2  """,""""""
"""""","""palevioletred3""",""""""
"""""","""palevioletred4""",""""""
"""""","""maroon1""",""""""
"""""","""maroon2""",""""""
"""""","""maroon3""",""""""
"""""","""maroon4""",""""""
"""""","""violetred1""",""""""
"""""","""violetred2""",""""""
"""""","""violetred3""",""""""
"""""","""violetred4""",""""""
"""""","""magenta1""",""""""
"""""","""magenta2""",""""""
"""""","""magenta3""",""""""
"""""","""magenta4""",""""""
"""""","""orchid1""",""""""
"""""","""orchid2""",""""""
"""""","""orchid3""",""""""
"""""","""orchid4""",""""""
"""""","""plum1""",""""""
"""""","""plum2""",""""""
"""""","""plum3""",""""""
"""""","""plum4""",""""""
"""""","""mediumorchid1""",""""""
"""""","""mediumorchid2""",""""""
"""""","""mediumorchid3""",""""""
"""""","""mediumorchid4""",""""""
"""""","""darkorchid1""",""""""
"""""","""darkorchid2""",""""""
"""""","""darkorchid3""",""""""
"""""","""darkorchid4""",""""""
"""""","""purple1""",""""""
"""""","""purple2""",""""""
"""""","""purple3""",""""""
"""""","""purple4""",""""""
"""""","""mediumpurple1""",""""""
"""""","""mediumpurple2""",""""""
"""""","""mediumpurple3""",""""""
"""""","""mediumpurple4""",""""""
"""""","""thistle1""",""""""
"""""","""thistle2""",""""""
"""""","""thistle3""",""""""
"""""","""thistle4""",""""""
"""""","""gray0""",""""""
"""""","""gray1""",""""""
"""""","""gray2""",""""""
"""""","""gray3""",""""""
"""""","""gray4""",""""""
"""""","""gray5""",""""""
"""""","""gray6""",""""""
"""""","""gray7""",""""""
"""""","""gray8""",""""""
"""""","""gray9""",""""""
"""""","""gray10""",""""""
"""""","""gray11""",""""""
"""""","""gray12""",""""""
"""""","""gray13""",""""""
"""""","""gray14""",""""""
"""""","""gray15""",""""""
"""""","""gray16""",""""""
"""""","""gray17""",""""""
"""""","""gray18""",""""""
"""""","""gray19""",""""""
"""""","""gray20""",""""""
"""""","""gray21""",""""""
"""""","""gray22""",""""""
"""""","""gray23""",""""""
"""""","""gray24""",""""""
"""""","""gray25""",""""""
"""""","""gray26""",""""""
"""""","""gray27""",""""""
"""""","""gray28""",""""""
"""""","""gray29""",""""""
"""""","""gray30""",""""""
"""""","""gray31""",""""""
"""""","""gray32""",""""""
"""""","""gray33""",""""""
"""""","""gray34""",""""""
"""""","""gray35""",""""""
"""""","""gray36""",""""""
"""""","""gray37""",""""""
"""""","""gray38""",""""""
"""""","""gray39""",""""""
"""""","""gray40""",""""""
"""""","""gray41""",""""""
"""""","""gray42""",""""""
"""""","""gray43""",""""""
"""""","""gray44""",""""""
"""""","""gray45""",""""""
"""""","""gray46""",""""""
"""""","""gray47""",""""""
"""""","""gray48""",""""""
"""""","""gray49""",""""""
"""""","""gray50""",""""""
"""""","""gray51""",""""""
"""""","""gray52""",""""""
"""""","""gray53""",""""""
"""""","""gray54""",""""""
"""""","""gray55""",""""""
"""""","""gray56""",""""""
"""""","""gray57""",""""""
"""""","""gray58""",""""""
"""""","""gray59""",""""""
"""""","""gray60""",""""""
"""""","""gray61""",""""""
"""""","""gray62""",""""""
"""""","""gray63""",""""""
"""""","""gray64""",""""""
"""""","""gray65""",""""""
"""""","""gray66""",""""""
"""""","""gray67""",""""""
"""""","""gray68""",""""""
"""""","""gray69""",""""""
"""""","""gray70""",""""""
"""""","""gray71""",""""""
"""""","""gray72""",""""""
"""""","""gray73""",""""""
"""""","""gray74""",""""""
"""""","""gray75""",""""""
"""""","""gray76""",""""""
"""""","""gray77""",""""""
"""""","""gray78""",""""""
"""""","""gray79""",""""""
"""""","""gray80""",""""""
"""""","""gray81""",""""""
"""""","""gray82""",""""""
"""""","""gray83""",""""""
"""""","""gray84""",""""""
"""""","""gray85""",""""""
"""""","""gray86""",""""""
"""""","""gray87""",""""""
"""""","""gray88""",""""""
"""""","""gray89""",""""""
"""""","""gray90""",""""""
"""""","""gray91""",""""""
"""""","""gray92""",""""""
"""""","""gray93""",""""""
"""""","""gray94""",""""""
"""""","""gray95""",""""""
"""""","""gray96""",""""""
"""""","""gray97""",""""""
"""""","""gray98""",""""""
"""""","""gray99""",""""""
"""""","""gray100""",""""""
"""""","""darkgray""",""""""
"""""","""darkblue""",""""""
"""""","""darkcyan""",""""""
"""""","""darkmagenta""",""""""
"""""","""darkred""",""""""
"""""","""lightgreen""",""""""
"""""","""from scaler ""","""XP["""
"""""","""from untang 2 ""","""u-sbƂ閡v2"""
"""""","""oh bugger""","""AjF"""
"""""","""logic error""","""_"""
"""""","""box""",""""""
"""""","""rectangle""","""`"""
"""""","""oval""","""ȉ~`"""
"""""","""diamond""","""_Ch"""
"""""","""filled""","""ςɂ܂B"""
"""""","""slash""","""XbV"""
"""""","""eof , ""","""eof"""
"""""","""got a number , ""","""𓾂܂B"""
"""""","""digraph""","""A"""
"""""","""expected 'digraph'""","""\zꂽ'A'"""
"""""","""expected a Graph Name""","""҂Ăa Graph Name"""
"""""","""expected '{'""","""\zꂽ'{'"""
"""""","""expects a STMT_LIST item or '}'""","""'ASTMT_LIST̕iڂ'}'\z܂B"""
"""""","""graph""","""Ot"""
"""""","""node""","""m[h"""
"""""","""edge""",""""""
"""""","""expected a '['""","""҂ĂaA'A'"""
"""""","""expected 'graph' or 'node' or 'edge'""","""\zꂽ'Ot'A'm[h'܂''"""
"""""","""error occurred checking for an edge""","""́AȂǂ`FbNȂA܂B"""
"""""","""error occurred in node_id""","""̓m[h_ChŔ܂B"""
"""""","""an edge ,no id""","""ACh܂B"""
"""""","""error getting target of edge""","""̖ڕWɓ"""
"""""","""error in attr_list""","""attr_Xgɂ"""
"""""","""color""","""F"""
"""""","""error getting color""","""F𓾂"""
"""""","""fontcolor""",""""""
"""""","""error getting font color""","""tHgF𓾂"""
"""""","""fontsize""","""tHgTCY"""
"""""","""error getting font size""","""tHgTCY𓾂"""
"""""","""label""","""x"""
"""""","""error getting label""","""xɓ"""
"""""","""shape""","""`"""
"""""","""error getting shape""","""`𓾂"""
"""""","""style""","""X^C"""
"""""","""error getting style""","""X^C𓾂"""
"""""","""data""","""f[^"""
"""""","""error getting data""","""f[^𓾂"""
"""""","""Tree View""","""؂̎_"""
"""""","""Unhide all Nodes""","""Unhideׂ͂āANodesłB"""
"""""","""Select Font""","""tHgIĂB"""
"""""","""Case Sensitive""","""啶Ə"""
"""""","""Use Classifier...""","""NVt@CAgpĂc"""
"""""","""Add Instances To Viewer""","""r[A[ɗĂB"""
"""""","""Fit to Screen""","""XN[ɍĂB"""
"""""","""Center on Top Node""","""gbvm[h̏̃Z^["""
"""""","""Auto Scale""","""XP["""
"""""","""availble Instances data for ""","""availble Instancesf[^"""
"""""","""this Node.""","""NodeB"""
"""""","""selected Node to perform ""","""IꂽNode"""
"""""","""this operation on.""","""̑AIłB"""
"""""","""Remove Child Nodes""","""qm[h菜ĂB"""
"""""","""classify_child""","""_q𕪗ނĂB"""
"""""","""send_instances""","""_𑗂ĂB"""
"""""","""available Decsion Tree to ""","""p\Decsion Tree"""
"""""","""Error, there is no ""","""A܂B"""
"""""","""selected Node to perform this ""","""sIꂽNode"""
"""""","""operation on.""","""AIłB"""
"""""","""Error!""","""!"""
"""""","""Accept The Tree""","""؂󂯓ĂB"""
"""""","""Sorry, there is no ""","""݂܂A܂B"""
"""""","""available Decision Tree to ""","""p\Decision Tree"""
"""""","""perform this operation on.""","""̑sĂBIB"""
"""""","""Sorry!""","""݂܂!"""
"""""","""Size 24""",""""""
"""""","""Size 22""",""""""
"""""","""Size 20""",""""""
"""""","""Size 18""",""""""
"""""","""Size 16""",""""""
"""""","""Size 14""",""""""
"""""","""Size 12""",""""""
"""""","""Size 10""",""""""
"""""","""Size 8""",""""""
"""""","""Size 6""",""""""
"""""","""Size 4""",""""""
"""""","""Size 2""",""""""
"""""","""Size 1""",""""""
"""""","""Hide Descendants""","""qBĂB"""
"""""","""Create Child Nodes""","""qm[h쐬ĂB"""
"""""","""Visualize The Node""","""m[hzĂB"""
"""""","""ahuh ""","""ahuh"""
"""""","""this is seriously pissing me off""","""͐^Ɏ{点Ă܂B"""
"""""","""here""",""""""
"""""","""the timer didn't end in time""","""^C}͎ԓɁAI܂łB"""
"""""","""A Name""","""O"""
"""""","""counter counted ""","""JE^͐܂B"""
"""""","""there are ""","""܂B"""
"""""",""" nodes""",""" m[h"""
"""""","""Undo""","""AhD"""
"""""","""Viewer""","""r[A["""
"""""","""Setting attribute bar colour to: ""","""ݒ肵āAȉ̂Ƃ̂߂ɐFւĂB """
"""""","""Can't display more than 512 attributes!""","""512ȏ̑\邱Ƃł܂!"""
"""""","""Usage : weka.gui.visualize.AttributePanel ""","""p@: weka.gui.visualize.AttributePanel"""
"""""","""<dataset> [class col]""","""<f[^Zbg>NX"""
"""""","""Weka Explorer: Attribute""","""Weka GNXv[[: """
"""""","""X index changed to : ""","""XCfbNX͈ȉ̂Ƃ̂߂ɕω܂B """
"""""","""Y index changed to : ""","""YCfbNX͈ȉ̂Ƃ̂߂ɕω܂B """
"""""","""Usage : weka.gui.visualize.ClassPanel <dataset> ""","""p@: weka.gui.visualize.ClassPanel<f[^Zbg>"""
"""""","""[class col]""","""NX"""
"""""","""Weka Explorer: Class""","""Weka GNXv[[: NX"""
"""""","""xScale = ""","""xScale="""
"""""",""", yScale = """,""", yScale="""
"""""","""The file is not set!""","""t@C͐ݒ肳܂!"""
"""""","""The component is not set!""","""R|[lg͐ݒ肳܂!"""
"""""","""JPEG-Image""","""JPEG-C[W"""
"""""","""Select new Color""","""VColorIĂB"""
"""""","""Usage : weka.gui.visualize.LegendPanel ""","""p@: weka.gui.visualize.LegendPanel"""
"""""","""<dataset> [dataset2], [dataset3],...""","""<f[^Zbg>dataset2Adataset3c"""
"""""","""Weka Explorer: Legend""","""Weka GNXv[[: `"""
"""""","""Update""","""Abvf[g"""
"""""","""Select Attributes""","""I"""
"""""","""SubSample % :""","""SubSample %:"""
"""""","""PlotSize: [100]""","""vbgGȂ傫: """
"""""","""PointSize: [10]""","""_̑傫: """
"""""","""Dialog""","""Θb"""
"""""","""Attribute Selection Panel""","""Ipl"""
"""""","""Cancel""","""LZ"""
"""""","""Size: ""","""TCY: """
"""""",""" Extpad: """,""""""
"""""",""" selected: """,""" I: """
"""""","""PlotSize: [""","""vbgGȂ傫: ["""
"""""","""PointSize: [""","""_̑傫: ["""
"""""","""Random Seed: ""","""_̎: """
"""""","""Subsample as""","""Subsampleł"""
"""""","""% of input: ""","""%̓: """
"""""","""Done""","""܂B"""
"""""","""Subsample % Panel""","""Subsample%pl"""
"""""","""PointSize: [1]""","""_̑傫: [1]"""
"""""","""Jitter: ""","""W^[: """
"""""","""Class Colour""","""NXF"""
"""""",""" Plot Matrix""","""񎟌vbg"""
"""""","""gettingPercent: """,""""""
"""""","""100""",""""""
"""""","""Weka Explorer: MatrixPanel""","""Weka GNXv[[: MatrixPanel"""
"""""","""Set Instances""","""CX^Xݒ肵ĂB"""
"""""","""Usage: MatrixPanel <arff file>""","""p@: MatrixPanel<arfft@C>"""
"""""","""arff""",""""""
"""""","""You chose to open this file: ""","""Ȃ́Ãt@CĴIт܂: """
"""""","""Loaded: ""","""[h: """
"""""","""\nRelation: ""","""\n֌W:"""
"""""","""\nAttributes: ""","""\n: """
"""""","""The attributes are: ""","""͈ȉ̒ʂłB """
"""""","""SansSerif""",""""""
"""""","""blah""",""""""
"""""","""Weka Explorer: Visualizing ""","""Weka GNXv[[: """
"""""","""Master Plot""","""}X^[vbg"""
"""""",""" (click to enlarge)""",""" (g傷邽߂ɁANbN܂)"""
"""""","""Matrix Panel""","""}gNXpl"""
"""""","""compainion""",""""""
"""""","""Setting axis colour to: ""","""̐Fݒ:  """
"""""","""Warning: no configuration property found in ""","""x: ŌȂ\̓S"""
"""""","""Setting background colour to: ""","""obNOEhݒ肵āAȉ̂Ƃ̂߂ɒFĂB """
"""""","""Setting Instances""","""f[^Zbgݒ"""
"""""","""master plot""","""vbg"""
"""""","""No instances in plot data!""","""Adf[^ŗႪ܂!"""
"""""","""Plot2D :Plot data's instances are incompatable ""","""Plot2D:Plotf[^̗incompatablełB"""
"""""",""" with master plot""",""" vbg"""
"""""","""\nPlot : ""","""\nvbg : """
"""""","""\nInstance: ""","""\nf[^:"""
"""""","""Missing""","""܂B"""
"""""","""Weka : Instance info""","""Weka : f[^̏"""
"""""","""Monospaced""","""Monospaced܂B"""
"""""","""Extending colour map""","""J[}bv̊g"
"""""","""Usage : weka.gui.visualize.Plot2D ""","""p@: weka.gui.visualize.Plot2D"""
"""""","""new plot""","""Vvbg"""
"""""","""Instance_number""","""_"""
"""""","""first""","""1Ԗ"""
"""""","""PlotData2D: Shape type array must have the same ""","""PlotData2D: ^Cv񂳂`͓炢Ȃ΂Ȃ܂B"""
"""""","""PlotData2D: Shape type vector must have the same ""","""PlotData2D: ^CvxNgɂ͓悤ɂȂ΂ȂȂ`"""
"""""","""PlotData2D: Shape size array must have the same ""","""PlotData2D: TCYzɂ͓悤ɂȂ΂ȂȂ`"""
"""""","""PlotData2D: Shape size vector must have the same ""","""PlotData2D: TCYxNgɂ͓悤ɂȂ΂ȂȂ`"""
"""""","""number of entries as number of data points!""","""f[^|Cg̐ƂẴGg[̐!"""
"""""","""PlotData2D: connect points array must have the ""","""PlotData2D: z񂪎Ȃ΂ȂȂ|CgڑĂB"""
"""""","""same number of entries as number of data points!""","""f[^|Cg̐ƂẴGg[̓!"""
"""""","""Setting connect points ""","""ZbgāA|CgڑĂB"""
"""""","""Microsoft Sans Serif""",""""""
"""""","""MicrosoftSansSerif""",""""""
"""""","""%!PS-Adobe-3.0 EPSF-3.0""",""""""
"""""","""%%BoundingBox: 0 0 """,""""""
"""""","""%%CreationDate: """,""""""
"""""","""/Oval { % x y w h filled""","""y w hςɂ/ȉ~`{%x"""
"""""","""x w 2 div add y h 2 div sub translate""","""x w2div́Ay h2div͂|󂳂ƌ܂B"""
"""""","""1 h w div scale""","""1h w divXP["""
"""""","""filled {0 0 moveto} if""","""{0 0moveto}ςɂĂ܂B"""
"""""","""0 0 w 2 div 0 360 arc""","""0 0 w2div0 360A[N"""
"""""","""filled {closepath fill} {stroke} ifelse grestore} bind def""","""ςɂꂽ{closepathl}{Xg[N}ifelse grestore} Ђdef"""
"""""","""/Rect { % x y w h filled""","""y w hςɂ/Rect{%x"""
"""""","""/filled exch def /h exch def /w exch def /y exch def /x exch def""","""/ςɂꂽexch def/h exch def/w exch def/y exch def/x exch def"""
"""""","""newpath ""","""newpath"""
"""""","""x y moveto""",""""""
"""""","""w 0 rlineto""","""w0rlineto"""
"""""","""0 h neg rlineto""",""""""
"""""","""w neg 0 rlineto""","""w neg0rlineto"""
"""""","""closepath""",""""""
"""""","""filled {fill} {stroke} ifelse} bind def""","""ςɂꂽ{l}{Xg[N}ifelse} Ђdef"""
"""""","""%%BeginProlog\n%%EndProlog""",""""""
"""""","""%%Page 1 1""","""%%1 1Ăяo܂B"""
"""""","""%create""","""%͍쐬܂B"""
"""""","""gsave""",""""""
"""""",""" translate""",""" |󂵂ĂB"""
"""""",""" scale""",""" XP["""
"""""","""false 3 colorimage""","""U3colorimage"""
"""""","""grestore""",""""""
"""""",""" moveto """,""" moveto"""
"""""",""" lineto stroke""",""" linetoXg[N"""
"""""",""" false Oval""",""" UOval"""
"""""",""" false Rect""",""" URect"""
"""""",""" moveto""",""""""
"""""",""") show stroke""",""") Xg[NĂB"""
"""""",""" true Oval""",""" {Oval"""
"""""","""% fillRect""","""%fillRect"""
"""""",""" true Rect""",""" {Rect"""
"""""",""" setrgbcolor""",""""""
"""""","""switched font from '""","""'̂؂芷܂'"""
"""""","""Courier""","""}g"""
"""""",""" findfont""",""""""
"""""",""" scalefont setfont""",""""""
"""""","""translate with x = ""","""x=ŁA|󂵂ĂB"""
"""""",""" and y = """,""" āAy="""
"""""","""Postscript-File (EPS)""","""ǐLt@C(EPS)"""
"""""","""building TreeVisualizer...""","""rTreeVisualizerc"""
"""""","""digraph atree { top [label=""the top""] a [label=""the first node""] b [label=""the second nodes""] c [label=""comes off of first""] top->a top->b b->c }""","""Aatreeu{[Av u[v=xĂAvAv uŏ̃m[hv=xȂAvAbAv u2Ԗڂ̃m[hv=xȂAvAcAx=AvAuŏɂAvAvA[->a[->b b->c}"""
"""""","""outputting to '""","""'óA'"""
"""""","""done!""","""ɂ!"""
"""""","""Save as...""","""Oĕۑ"""
"""""","""PrintableComponentToolTipShow""",""""""
"""""","""PrintableComponentToolTipUserAsked""",""""""
"""""","""false""",""""""
"""""",""": DEBUG ON""",""": fobOAI"""
"""""","""Some panels enable the user to save the content as JPEG or EPS.\n""","""ψ̒ɂ̓[UJPEGEPS\nƂēeۑ̂\ɂ̂܂B"""
"""""","""In order to see which panels support this, a tooltip can be ""","""ǂ̃plx邩mF邽߂ɁAtooltip͊mF邱Ƃł܂B"""
"""""","""displayed. Enable tooltip?""","""\B tooltipLɂ܂?"""
"""""","""ToolTip for Panels...""","""pl̂߂́cToolTip"""
"""""","""You can still manually enable or disable the ToolTip via the following property\n""","""Ȃ́Aȉ̓\nʂĂ܂蓮ToolTipLɂ邩A܂͖ɂ邱Ƃł܂B"""
"""""","""in the following file\n""","""ȉ̃t@C\n"""
"""""","""Error saving the props file!\n""","""xɃt@C!\nߖ񂷂"""
"""""","""If you want to disable these messages from popping up, place a file\n""","""}Ɍ̂̂̃bZ[W𖳌ɂȂAt@C\n𓊎ĂB"""
"""""","""called 'Visualize.props' either in your home directory or in the directory\n""","""Ȃ̃z[fBNgfBNg\n'Visualize.props'ƌĂ΂܂B"""
"""""","""you're starting Weka from and add the following lines:\n""","""WekanĂAȉ̐: \nĂB"""
"""""","""=true\n""","""={\n"""
"""""","""Error...""","""c"""
"""""","""Click left mouse button while holding <alt> and <shift> to display a save dialog.""","""Z[uΘb\邽߂<alt>><VtgێĂԁA}EX{^NbNĂB"""
"""""","""X: False Positive Rate (Num)""","""X: af[g(k)"""
"""""","""Y: True Positive Rate (Num)""","""Y: ^̗z̃[g(k)"""
"""""","""clicked""","""NbN܂B"""
"""""","""Part of user input so had to""","""āA[U͂̈ꕔ͂Ȃ΂Ȃ܂łB"""
"""""",""" catch here""",""" ł̃Lb`"""
"""""","""Error : """,""": """
"""""","""out""","""AEg"""
"""""","""WHAT?!?!?!?!!?!??!?!""","""ł?!?!??!?!"""
"""""","""Warning : data contains more attributes ""","""x: f[^́A葽̑܂ł܂B"""
"""""","""than can be displayed as attribute bars.""","""o[Ƃĕ\邱ƂłB"""
"""""","""Reset""","""Zbg"""
"""""",""" hoi""",""""""
"""""","""Submit""","""s"""
"""""","""Clear""","""NA"""
"""""","""Save""","""ۑ"""
"""""","""Arff data files""","""Arfff[^t@C"""
"""""","""Jitter""","""W^["""
"""""","""true""",""""""
"""""","""Displaying attribute bars ""","""o[\܂B"""
"""""","""Looking for preferred visualization dimensions for ""","""ŝ悢z@͌܂B"""
"""""","""No preferred X dimension found in ""","""@͒X܂łŝ悢B"""
"""""","""Setting preferred X dimension to ""","""ŝ悢X@ݒ肵܂B"""
"""""","""No preferred Y dimension found in ""","""@͒Y܂łŝ悢B"""
"""""","""Setting preferred dimension Y to ""","""ŝ悢@Yݒ肵܂B"""
"""""","""No preferred Colour dimension found in ""","""@͒Colour܂łŝ悢B"""
"""""",""" for """,""" for"""
"""""","""Setting preferred Colour dimension to ""","""ŝ悢Colour@ݒ肵܂B"""
"""""","""Select the attribute for the x axis""","""x̂߂ɑIĂB"""
"""""","""Select the attribute for the y axis""","""ŷ߂ɑIĂB"""
"""""","""Select the attribute to colour on""","""FɃIȑIĂB"""
"""""","""Select the shape to use for data selection""","""f[^I̗prւ̌`IĂB"""
"""""","""Save the visible instances to a file""","""ĂCX^Xt@Cɕۑ"""
"""""","""Class colour""","""NX̐F"""
"""""","""Plot""","""vbg"""
"""""","""Select Instance""","""vbǧ`IĂ"""
"""""","""Rectangle""","""`"""
"""""","""Polygon""","""p`"""
"""""","""Polyline""",""""""
"""""","""x index is out of range!""","""xCfbNX͔͈͂EĂ܂!"""
"""""","""y index is out of range!""","""yCfbNX͔͈͂EĂ܂!"""
"""""","""s index is out of range!""","""sCfbNX͔͈͂EĂ܂!"""
"""""",""" (Nom)""",""" (`^)"""
"""""",""" (Num)""",""" (l^)"""
"""""",""" (Str)""",""" (^)"""
"""""","""Colour: ""","""F: """
"""""","""Found preferred X dimension""","""ŝ悢X@ݒ肵Ă"""
"""""","""Found preferred Y dimension""","""ŝ悢Y@ݒ肵Ă"""
"""""","""Found preferred Colour dimension""","""ŝ悢FԂݒ肵Ă"""
"""""","""Plot: ""","""vbg: """
"""""","""Problem setting preferred Visualization dimensions""","""ŝ悢Visualization@ݒ肷邱Ƃɂ"""
"""""","""Usage : weka.gui.visualize.VisualizePanel ""","""p@: weka.gui.visualize.VisualizePanel"""
"""""","""<dataset> [<dataset> <dataset>...]""",""""""
"""""","""Weka Explorer: Visualize""","""Weka GNXv[[: """
"""""","""Loading instances from ""","""CX^X̃[h"""
"""""","""Master plot""","""}X^[vbg"""
"""""","""Plot ""","""vbg"""
"""""","""Warning: no configuration property found in""","""x: ŌȂ\̓S"""
"""""",""" for weka.gui.visualize.precision. Using""",""" weka.gui.visualize.precision̂߂ɁB gp"""
"""""",""" default instead.""",""" ɃftHgƂĂB"""
"""""","""Setting numeric precision to: ""","""ȉւ̃ZbgĂ鐔lx """
"""""","""VisualizeUtils: Could not read a visualization configuration file.\n""","""VisualizeUtils: z\t@C\nǂނƂł܂łB"""
"""""","""An example file is included in the Weka distribution.\n""","""̃t@CWekazɊ܂܂ĂA\n"""
"""""","""This file should be named """"","""̃t@CׂłAuv"""
"""""","""""  and\n""","""uu\nv"""
"""""","""should be placed either in your user home (which is set\n""","""Ȃ̃[ỦƂɒuׂłA(Zbg\n͂ǂłB"""
"""""","""or the directory that java was started from\n""","""܂́AjavafBNg\nn߂܂B"""
"""""","""Plot2D""",""""""
"""""","""VisualizeUtils: Problem parsing colour property ""","""VisualizeUtils: \͐F̓"""
"""""","""value (""","""lA("""
"""""","""black""",""""""
"""""","""blue""",""""""
"""""","""cyan""",""""""
"""""","""darkGray""",""""""
"""""","""gray""",""""""
"""""","""green""",""""""
"""""","""lightGray""",""""""
"""""","""magenta""",""""""
"""""","""orange""",""""""
"""""","""pink""",""""""
"""""","""red""",""""""
"""""","""white""",""""""
"""""","""yellow""",""""""
"""""","""VisualizeUtils: colour property name not recognized ""","""VisualizeUtils: FȂF̖̓"""
"""""","""Weka Tasks""","""Weka ^XN"""
