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))
}