func main() { flag.Parse() if flag.NArg() != 1 && flag.NArg() != 2 { flag.Usage() os.Exit(1) } config := common.ReadConfigOrExit(flag.Arg(0)) transitionSystem, ok := common.TransitionSystems[config.Parser.System] if !ok { log.Fatalf("Unknown transition system: %s", config.Parser.System) } blasImpl, ok := blasImpls[*blas] if !ok { log.Fatalf("Unknown blas implementation: %s", *blas) } labelNumberer := common.ReadTransitionsOrExit(config.Parser.Transitions, transitionSystem) parseNetwork := common.ReadModelOrExit(config.Parser.Model, blasImpl) var morphNetwork *network.Network if len(config.Parser.MorphModel) != 0 { morphNetwork = common.ReadModelOrExit(config.Parser.MorphModel, blasImpl) } ilas := common.ReadIlasOrExit(config.Parser.Inputs) normalizer := common.ReadNormalizerOrExit(config.Parser.Normalisation) layerEmbeddings := common.MustReadAllEmbeddings(config.Embeddings) realizer := input.NewInputVectorRealizer(ilas, layerEmbeddings, normalizer) var guide system.Guide if morphNetwork != nil { log.Print("Using morphology") guide = network.NewMorphGuide(parseNetwork, morphNetwork, *labelNumberer, realizer) } else { guide = network.NewGuide(parseNetwork, *labelNumberer, realizer) } parser := system.NewGreedyParser(transitionSystem, guide) if *cpuprofile != "" { f, err := os.Create(*cpuprofile) if err != nil { log.Fatal(err) } pprof.StartCPUProfile(f) defer pprof.StopCPUProfile() } start := time.Now() run(parser) elapsed := time.Since(start) log.Printf("Parsing took %s", elapsed) }
func main() { flag.Parse() if flag.NArg() != 3 { flag.Usage() os.Exit(1) } config := common.ReadConfigOrExit(flag.Arg(0)) if !config.Embeddings.Word.NormalizeInput { log.Println("Token layer inputs will not be normalized") } if !config.Embeddings.Tag.NormalizeInput { log.Println("Tag layer inputs will not be normalized") } if !config.Embeddings.DepRel.NormalizeInput { log.Println("Dependency layer inputs will not be normalized") } if !config.Embeddings.Feature.NormalizeInput { log.Println("Feature layer inputs will not be normalized") } if !config.Embeddings.Char.NormalizeInput { log.Println("Character layer inputs will not be normalized") } var normalizer *input.Normalizer normFilename := config.Parser.Normalisation if fileExists(normFilename) { log.Printf("Read normalization parameters from %s", normFilename) normalizer = common.ReadNormalizerOrExit(normFilename) } else { log.Print("Extracting normalization parameters from data") acc := input.NewAccumulator(normLayers(config), func() normalization.Accumulator { return normalization.NewVarianceAccumulator() }) err := extractParameters(flag.Arg(1), acc) common.ExitIfError("Error extracting normalizer parameters: ", err) normalizer = acc.Normalizer() err = writeNormalizer(normFilename, normalizer) common.ExitIfError("Error writing normalizer parameters: ", err) } log.Printf("Normalizing data from %s and writing to %s", flag.Arg(1), flag.Arg(2)) normalizeData(normalizer, flag.Arg(1), flag.Arg(2)) }