entwurzeln: Python / Numpy-basierte Bibliothek zum Lesen und Schreiben von ROOT-Dateien
Überblick
Die vom CERN entwickelte Analysebibliothek ROOT (C ++ -basiert) verwaltet und speichert Daten in einer \ * .root-Datei.
uproot ist eine Python / Numpy-basierte Bibliothek, die diese \ * .root-Datei mit hoher Geschwindigkeit liest und schreibt.
Ich kann keine japanische Dokumentation finden, da sie relativ früh veröffentlicht wurde, aber sie scheint sehr nützlich zu sein, um ROOT, das hauptsächlich für Elementarteilchen, Atomwaffen und Weltraumexperimente verwendet wird, mit einem Python-basierten Framework für maschinelles Lernen zu verbinden. Also habe ich versucht zusammenzufassen.
Offizielles Dokument
ROOT Home Page
Hintergrund
Wenn Sie maschinelles Lernen basierend auf der erstellten ROOT-Datei ausführen möchten, gibt es mehrere mögliche Methoden.
- Lesen Sie im CSV-Format mit dem ROOT-Makro
- Lesen Sie mit pyROOT usw.
1 ist offensichtlich ärgerlich, weil Sie sowohl das ROOT-Makro schreiben müssen, um in das CSV-Format zu konvertieren, als auch den Python-Code, um CSV zu lesen und es in ein Numpy-Array usw. zu konvertieren. Auf der anderen Seite scheint es ziemlich schwierig zu sein, pyROOT in einer Cloud-Umgebung wie Google Colab fest einzuführen, was auf den ersten Blick einfach zu sein scheint. (Es scheint möglich, aber ... Link)
In der Zwischenzeit kann die kürzlich veröffentlichte Entwurzelung die ROOT-Datei so verarbeiten, wie sie ist, und die Einführungskosten sind nicht hoch. Ich denke, dass die Entwurzelung sehr hilfreich sein wird. Darüber hinaus hat es eine sehr wichtige Funktion für den Einsatz beim maschinellen Lernen, dass es eine große Datenmenge mit hoher Geschwindigkeit lesen kann. Laut dem Entwicklungsteam wird eine Lesegeschwindigkeit erreicht, die den ursprünglichen ROOT für große Dateien überschreitet.
Bereits LHC-Experiment (Large Hadron Collider) und [XENON-nT-Experiment](https://science.purdue.edu/xenon1t/ Es scheint, dass es viele Benutzer in großen Experimenten (in der Nachbarschaft) gibt, wie z. B.), und es scheint, dass die Entwicklung in Zukunft fortgesetzt wird. Es wird auch in [am LHC entwickeltem MLaaS] verwendet (https://arxiv.org/abs/1811.04492).
Installation
Es kann mit dem Befehl pip installiert werden.
pip install uproot
Sie können es auch mit conda installieren.
conda config --add channels conda-forge # if you haven't added conda-forge already
conda install uproot
Die Installation von C ++ ROOT ist für die Verwendung von Uroot nicht erforderlich.
Wie benutzt man
In diesem Artikel konzentrieren wir uns auf die grundlegendsten Anwendungen. uproot verwendet den Namen des ROOT-Objekts zum Lesen und Schreiben.
Erstellen Sie eine geeignete ROOT-Datei
Ein geeignetes ROOT-Makro. Führen Sie root -l GenRootFile.cpp aus.
GenRootFile.cpp
void GenRootFile(){
TFile* fout = new TFile("sample.root","recreate");
TTree* tout = new TTree("tout","tout");
Int_t event;
Double_t val;
tout->Branch("event",&event,"event/I");
tout->Branch("val" ,&val ,"val/D");
TF1* fgaus = new TF1("fgaus","[0]*TMath::Gaus(x,[1],[2])",-10,10);
fgaus->SetParameters(1,0,2);
TH1D* hgaus = new TH1D("hgaus","hgaus",20,-10,10);
Int_t Nevent = 100;
for (Int_t ievent = 0; ievent < Nevent; ievent++) {
event = ievent;
val = fgaus->GetRandom();
hgaus ->Fill(val);
tout ->Fill();
}
fout ->cd();
tout ->Write();
hgaus->Write();
fout ->Close();
}
Beispielsweise wird das folgende Histogramm generiert.
Lesen Sie den Baum der Stammdatei
Zugriff mit dem Namen, den Tree hat (in diesem Fall "tout").
import uproot
file = uproot.open("sample.root")
tout = file["tout"] #TName
print(tout)
Greifen Sie auf die Elemente des Baums zu
Sie können den Tree Branch als Numpy-Array laden.
val = tout.array("val")
Histogramm laden
Das Histogramm kann ebenfalls gelesen werden.
hgaus = file["hgaus"] #Holen Sie sich von TName
print(hgaus.edges) #X-Achse des Histogramms
print(hgaus.values) #Y-Achse des Histogramms(Wert)
hgaus.show()
Das Ausführungsergebnis sieht so aus.
[-10. -9. -8. -7. -6. -5. -4. -3. -2. -1. 0. 1. 2. 3.
4. 5. 6. 7. 8. 9. 10.]
[ 0. 0. 0. 0. 0. 0. 5. 13. 17. 24. 20. 14. 2. 3. 1. 0. 1. 0.
0. 0.]
0 25.2
+---------------------------------------------------------------+
[-inf, -10) 0 | |
[-10, -9) 0 | |
[-9, -8) 0 | |
[-8, -7) 0 | |
[-7, -6) 0 | |
[-6, -5) 0 | |
[-5, -4) 0 | |
[-4, -3) 5 |************ |
[-3, -2) 13 |******************************** |
[-2, -1) 17 |****************************************** |
[-1, 0) 24 |************************************************************ |
[0, 1) 20 |************************************************** |
[1, 2) 14 |*********************************** |
[2, 3) 2 |***** |
[3, 4) 3 |******* |
[4, 5) 1 |** |
[5, 6) 0 | |
[6, 7) 1 |** |
[7, 8) 0 | |
[8, 9) 0 | |
[9, 10) 0 | |
[10, inf] 0 | |
+---------------------------------------------------------------+
Schreiben
Sie können auch eine neue ROOT-Datei erstellen, um ein Histogramm und einen neuen Baum wie folgt zu schreiben:
import numpy as np
t = uproot.newtree({"branch1": int,
"branch2": np.int32,
"branch3": uproot.newbranch(np.float64, title="This is the title")})
with uproot.recreate("example.root") as f:
f["hist"] = hgaus #Benennen Sie das Objekt entsprechend
f["t"] = t
Zusammenfassung
Ich fand heraus, dass ich ROOT-Dateien (schnell) in einer Python-Umgebung mit Uroot lesen und schreiben kann. Dies scheint besonders nützlich zu sein, wenn Sie große Dateien mit Python-basierten Frameworks für maschinelles Lernen (PyTorch, Tensorflow usw.) füttern möchten.
Recommended Posts