X-Git-Url: https://git.arvados.org/lightning.git/blobdiff_plain/d1971ed941bb36759c2b1a22ffb82f569a9feec0..0bdd658af496fbc2ca2f9e55a5f4ee6c18d06b66:/slicenumpy.go diff --git a/slicenumpy.go b/slicenumpy.go index f3f9cc7526..c3d02a99bc 100644 --- a/slicenumpy.go +++ b/slicenumpy.go @@ -8,6 +8,7 @@ import ( "bufio" "bytes" "encoding/gob" + "encoding/json" "errors" "flag" "fmt" @@ -43,6 +44,8 @@ type sliceNumpy struct { threads int chi2Cases []bool chi2PValue float64 + glmMinFrequency float64 + pcaComponents int minCoverage int includeVariant1 bool debugTag tagID @@ -51,6 +54,8 @@ type sliceNumpy struct { samples []sampleInfo trainingSet []int // samples index => training set index, or -1 if not in training set trainingSetSize int + pvalue func(onehot []bool) float64 + pvalueCallCount int64 } func (cmd *sliceNumpy) RunCommand(prog string, args []string, stdin io.Reader, stdout, stderr io.Writer) int { @@ -71,6 +76,7 @@ func (cmd *sliceNumpy) run(prog string, args []string, stdin io.Reader, stdout, arvadosVCPUs := flags.Int("arvados-vcpus", 96, "number of VCPUs to request for arvados container") projectUUID := flags.String("project", "", "project `UUID` for output data") priority := flags.Int("priority", 500, "container request priority") + preemptible := flags.Bool("preemptible", true, "request preemptible instance") inputDir := flags.String("input-dir", "./in", "input `directory`") outputDir := flags.String("output-dir", "./out", "output `directory`") ref := flags.String("ref", "", "reference name (if blank, choose last one that appears in input)") @@ -83,12 +89,13 @@ func (cmd *sliceNumpy) run(prog string, args []string, stdin io.Reader, stdout, onehotChunked := flags.Bool("chunked-onehot", false, "generate one-hot tile-based matrix per input chunk") samplesFilename := flags.String("samples", "", "`samples.csv` file with training/validation and case/control groups (see 'lightning choose-samples')") caseControlOnly := flags.Bool("case-control-only", false, "drop samples that are not in case/control groups") - onlyPCA := flags.Bool("pca", false, "generate pca matrix") - pcaComponents := flags.Int("pca-components", 4, "number of PCA components") + onlyPCA := flags.Bool("pca", false, "run principal component analysis, write components to pca.npy and samples.csv") + flags.IntVar(&cmd.pcaComponents, "pca-components", 4, "number of PCA components to compute / use in logistic regression") maxPCATiles := flags.Int("max-pca-tiles", 0, "maximum tiles to use as PCA input (filter, then drop every 2nd colum pair until below max)") debugTag := flags.Int("debug-tag", -1, "log debugging details about specified tag") flags.IntVar(&cmd.threads, "threads", 16, "number of memory-hungry assembly threads, and number of VCPUs to request for arvados container") - flags.Float64Var(&cmd.chi2PValue, "chi2-p-value", 1, "do Χ² test and omit columns with p-value above this threshold") + flags.Float64Var(&cmd.chi2PValue, "chi2-p-value", 1, "do Χ² test (or logistic regression if -samples file has PCA components) and omit columns with p-value above this threshold") + flags.Float64Var(&cmd.glmMinFrequency, "glm-min-frequency", 0.01, "skip GLM calculation on tile variants below this frequency in the training set") flags.BoolVar(&cmd.includeVariant1, "include-variant-1", false, "include most common variant when building one-hot matrix") cmd.filter.Flags(flags) err := flags.Parse(args) @@ -122,6 +129,7 @@ func (cmd *sliceNumpy) run(prog string, args []string, stdin io.Reader, stdout, Priority: *priority, KeepCache: 2, APIAccess: true, + Preemptible: *preemptible, } err = runner.TranslatePaths(inputDir, regionsFilename, samplesFilename) if err != nil { @@ -142,9 +150,10 @@ func (cmd *sliceNumpy) run(prog string, args []string, stdin io.Reader, stdout, "-samples=" + *samplesFilename, "-case-control-only=" + fmt.Sprintf("%v", *caseControlOnly), "-pca=" + fmt.Sprintf("%v", *onlyPCA), - "-pca-components=" + fmt.Sprintf("%d", *pcaComponents), + "-pca-components=" + fmt.Sprintf("%d", cmd.pcaComponents), "-max-pca-tiles=" + fmt.Sprintf("%d", *maxPCATiles), "-chi2-p-value=" + fmt.Sprintf("%f", cmd.chi2PValue), + "-glm-min-frequency=" + fmt.Sprintf("%f", cmd.glmMinFrequency), "-include-variant-1=" + fmt.Sprintf("%v", cmd.includeVariant1), "-debug-tag=" + fmt.Sprintf("%d", cmd.debugTag), } @@ -182,7 +191,7 @@ func (cmd *sliceNumpy) run(prog string, args []string, stdin io.Reader, stdout, } if *samplesFilename != "" { - cmd.samples, err = cmd.loadSampleInfo(*samplesFilename) + cmd.samples, err = loadSampleInfo(*samplesFilename) if err != nil { return err } @@ -279,6 +288,11 @@ func (cmd *sliceNumpy) run(prog string, args []string, stdin io.Reader, stdout, cmd.trainingSet[i] = -1 } } + if cmd.pvalue == nil { + cmd.pvalue = func(onehot []bool) float64 { + return pvalue(onehot, cmd.chi2Cases) + } + } } if cmd.filter.MinCoverage == 1 { // In the generic formula below, floating point @@ -290,39 +304,31 @@ func (cmd *sliceNumpy) run(prog string, args []string, stdin io.Reader, stdout, cmd.minCoverage = int(math.Ceil(cmd.filter.MinCoverage * float64(len(cmd.cgnames)))) } - { - samplesOutFilename := *outputDir + "/samples.csv" - log.Infof("writing sample metadata to %s", samplesOutFilename) - var f *os.File - f, err = os.Create(samplesOutFilename) - if err != nil { - return err - } - defer f.Close() - for i, si := range cmd.samples { - var cc, tv string - if si.isCase { - cc = "1" - } else if si.isControl { - cc = "0" - } - if si.isTraining { - tv = "1" - } else { - tv = "0" - } - _, err = fmt.Fprintf(f, "%d,%s,%s,%s\n", i, si.id, cc, tv) - if err != nil { - err = fmt.Errorf("write %s: %w", samplesOutFilename, err) - return err - } - } - err = f.Close() + if len(cmd.samples[0].pcaComponents) > 0 { + cmd.pvalue = glmPvalueFunc(cmd.samples, cmd.pcaComponents, cmd.glmMinFrequency) + // Unfortunately, statsmodel/glm lib logs stuff to + // os.Stdout when it panics on an unsolvable + // problem. We recover() from the panic in glm.go, but + // we also need to commandeer os.Stdout to avoid + // producing large quantities of logs. + stdoutWas := os.Stdout + defer func() { os.Stdout = stdoutWas }() + os.Stdout, err = os.Open(os.DevNull) if err != nil { - err = fmt.Errorf("close %s: %w", samplesOutFilename, err) return err } - log.Print("done") + } + + // cgnamemap[name]==true for samples that we are including in + // output + cgnamemap := map[string]bool{} + for _, name := range cmd.cgnames { + cgnamemap[name] = true + } + + err = writeSampleInfo(cmd.samples, *outputDir) + if err != nil { + return err } log.Info("indexing reference tiles") @@ -506,7 +512,7 @@ func (cmd *sliceNumpy) run(prog string, args []string, stdin io.Reader, stdout, if cmd.filter.MaxTag >= 0 && cg.StartTag > tagID(cmd.filter.MaxTag) { return errSkip } - if !matchGenome.MatchString(cg.Name) { + if !cgnamemap[cg.Name] { continue } // pad to full slice size @@ -1173,6 +1179,17 @@ func (cmd *sliceNumpy) run(prog string, args []string, stdin io.Reader, stdout, if err != nil { return err } + fnm = fmt.Sprintf("%s/stats.json", *outputDir) + j, err := json.Marshal(map[string]interface{}{ + "pvalueCallCount": cmd.pvalueCallCount, + }) + if err != nil { + return err + } + err = os.WriteFile(fnm, j, 0777) + if err != nil { + return err + } } if *onlyPCA { cols := 0 @@ -1207,7 +1224,7 @@ func (cmd *sliceNumpy) run(prog string, args []string, stdin io.Reader, stdout, } } log.Print("fitting") - transformer := nlp.NewPCA(*pcaComponents) + transformer := nlp.NewPCA(cmd.pcaComponents) transformer.Fit(mtxTrain.T()) log.Printf("transforming") pca, err := transformer.Transform(mtxFull.T()) @@ -1244,42 +1261,19 @@ func (cmd *sliceNumpy) run(prog string, args []string, stdin io.Reader, stdout, } log.Print("done") - samplesOutFilename := *outputDir + "/samples.csv" - log.Infof("writing sample metadata to %s", samplesOutFilename) - var f *os.File - f, err = os.Create(samplesOutFilename) - if err != nil { - return err - } - defer f.Close() - for i, si := range cmd.samples { - var cc, tv string - if si.isCase { - cc = "1" - } else if si.isControl { - cc = "0" - } - if si.isTraining { - tv = "1" - } else { - tv = "0" - } - var pcavals string + log.Print("copying pca components to sampleInfo") + for i := range cmd.samples { + cmd.samples[i].pcaComponents = make([]float64, outcols) for c := 0; c < outcols; c++ { - pcavals += fmt.Sprintf(",%f", pca.At(i, c)) - } - _, err = fmt.Fprintf(f, "%d,%s,%s,%s%s\n", i, si.id, cc, tv, pcavals) - if err != nil { - err = fmt.Errorf("write %s: %w", samplesOutFilename, err) - return err + cmd.samples[i].pcaComponents[i] = pca.At(i, c) } } - err = f.Close() + log.Print("done") + + err = writeSampleInfo(cmd.samples, *outputDir) if err != nil { - err = fmt.Errorf("close %s: %w", samplesOutFilename, err) return err } - log.Print("done") } } if !*mergeOutput && !*onehotChunked && !*onehotSingle && !*onlyPCA { @@ -1319,7 +1313,7 @@ type sampleInfo struct { // Read samples.csv file with case/control and training/validation // flags. -func (cmd *sliceNumpy) loadSampleInfo(samplesFilename string) ([]sampleInfo, error) { +func loadSampleInfo(samplesFilename string) ([]sampleInfo, error) { var si []sampleInfo f, err := open(samplesFilename) if err != nil { @@ -1353,17 +1347,75 @@ func (cmd *sliceNumpy) loadSampleInfo(samplesFilename string) ([]sampleInfo, err if idx != len(si) { return nil, fmt.Errorf("%s line %d: index %d out of order", samplesFilename, lineNum, idx) } + var pcaComponents []float64 + if len(split) > 4 { + for _, s := range split[4:] { + f, err := strconv.ParseFloat(s, 64) + if err != nil { + return nil, fmt.Errorf("%s line %d: cannot parse float %q: %s", samplesFilename, lineNum, s, err) + } + pcaComponents = append(pcaComponents, f) + } + } si = append(si, sampleInfo{ - id: split[1], - isCase: split[2] == "1", - isControl: split[2] == "0", - isTraining: split[3] == "1", - isValidation: split[3] == "0", + id: split[1], + isCase: split[2] == "1", + isControl: split[2] == "0", + isTraining: split[3] == "1", + isValidation: split[3] == "0" && len(split[2]) > 0, // fix errant 0s in input + pcaComponents: pcaComponents, }) } return si, nil } +func writeSampleInfo(samples []sampleInfo, outputDir string) error { + fnm := outputDir + "/samples.csv" + log.Infof("writing sample metadata to %s", fnm) + f, err := os.Create(fnm) + if err != nil { + return err + } + defer f.Close() + pcaLabels := "" + if len(samples) > 0 { + for i := range samples[0].pcaComponents { + pcaLabels += fmt.Sprintf(",PCA%d", i) + } + } + _, err = fmt.Fprintf(f, "Index,SampleID,CaseControl,TrainingValidation%s\n", pcaLabels) + if err != nil { + return err + } + for i, si := range samples { + var cc, tv string + if si.isCase { + cc = "1" + } else if si.isControl { + cc = "0" + } + if si.isTraining { + tv = "1" + } else if si.isValidation { + tv = "0" + } + var pcavals string + for _, pcaval := range si.pcaComponents { + pcavals += fmt.Sprintf(",%f", pcaval) + } + _, err = fmt.Fprintf(f, "%d,%s,%s,%s%s\n", i, si.id, cc, tv, pcavals) + if err != nil { + return fmt.Errorf("write %s: %w", fnm, err) + } + } + err = f.Close() + if err != nil { + return fmt.Errorf("close %s: %w", fnm, err) + } + log.Print("done") + return nil +} + func (cmd *sliceNumpy) filterHGVScolpair(colpair [2][]int8) bool { if cmd.chi2PValue >= 1 { return true @@ -1590,7 +1642,8 @@ func (cmd *sliceNumpy) tv2homhet(cgs map[string]CompactGenome, maxv tileVariantI if col < 4 && !cmd.includeVariant1 { continue } - p := pvalue(obs[col], cmd.chi2Cases) + atomic.AddInt64(&cmd.pvalueCallCount, 1) + p := cmd.pvalue(obs[col]) if cmd.chi2PValue < 1 && !(p < cmd.chi2PValue) { continue }