uproot: bibliothèque basée sur Python / Numpy pour lire et écrire des fichiers ROOT
Aperçu
La bibliothèque d'analyse ROOT (basée sur C ++) développée par le CERN gère et enregistre les données dans un fichier \ * .root.
uproot est une bibliothèque basée sur python / numpy qui lit et écrit ce fichier \ * .root à grande vitesse.
Je ne trouve aucune documentation japonaise car elle a été publiée relativement tôt, mais elle semble être très utile pour connecter ROOT, qui est principalement utilisé pour les particules élémentaires, les noyaux nucléaires et les expériences spatiales, avec un cadre d'apprentissage automatique basé sur python. J'ai donc essayé de résumer.
Document officiel
Page d'accueil ROOT
Contexte
Si vous souhaitez exécuter l'apprentissage automatique en fonction du fichier ROOT créé, plusieurs méthodes sont possibles.
- Lire au format csv avec la macro ROOT
- Lisez en utilisant pyROOT etc.
1 est évidemment ennuyeux car vous devez écrire à la fois la macro ROOT pour convertir au format csv et le code python pour lire csv et le convertir en tableau numpy, etc. D'autre part, 2 qui semble simple à première vue semble être assez difficile à introduire fermement pyROOT lors de l'exécution dans un environnement cloud tel que Google Colab. (Cela semble possible, mais ... lien)
Pendant ce temps, le déracinement récemment publié peut gérer le fichier ROOT tel quel, et le coût d'introduction n'est pas élevé.Je pense que le déracinement sera très utile. De plus, il possède une fonctionnalité très importante à utiliser dans l'apprentissage automatique: il peut lire une énorme quantité de données à haute vitesse. Selon l'équipe de développement, il atteint des vitesses de lecture supérieures à la ROOT d'origine pour les fichiers volumineux.
Déjà expérience LHC (Large Hadron Collider) et [expérience XENON-nT](https://science.purdue.edu/xenon1t/ Il semble qu'il y ait de nombreux utilisateurs dans des expériences majeures (dans le quartier) comme), et il semble que le développement se poursuivra dans le futur. Il est également utilisé dans MLaaS développé au LHC.
Installation
Il peut être installé avec la commande pip.
pip install uproot
Vous pouvez également l'installer avec conda.
conda config --add channels conda-forge # if you haven't added conda-forge already
conda install uproot
Il n'est pas nécessaire d'avoir C ++ ROOT installé pour utiliser le déracinement.
Comment utiliser
Dans cet article, nous nous concentrerons sur les utilisations les plus élémentaires. uproot utilise le nom de l'objet ROOT pour lire et écrire.
Créez un fichier ROOT approprié
Une macro ROOT appropriée. Exécutez root -l GenRootFile.cpp.
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();
}
Par exemple, l'histogramme suivant est généré.
Lire l'arborescence du fichier racine
Accès avec le nom de Tree ("tout" dans ce cas).
import uproot
file = uproot.open("sample.root")
tout = file["tout"] #TName
print(tout)
Accéder aux éléments de l'arbre
Vous pouvez charger la branche d'arbre en tant que tableau numpy.
val = tout.array("val")
Charger l'histogramme
L'histogramme peut également être lu.
hgaus = file["hgaus"] #Obtenir par TName
print(hgaus.edges) #Axe X de l'histogramme
print(hgaus.values) #Axe Y de l'histogramme(valeur)
hgaus.show()
Le résultat de l'exécution ressemble à ceci.
[-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 | |
+---------------------------------------------------------------+
l'écriture
Vous pouvez également créer un nouveau fichier ROOT pour écrire un histogramme et un nouvel arbre comme suit:
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 #Nommez l'objet de manière appropriée
f["t"] = t
Résumé
J'ai trouvé que je pouvais lire et écrire des fichiers ROOT (rapidement) dans un environnement python en utilisant uproot. Cela semble particulièrement utile lorsque vous souhaitez alimenter des fichiers volumineux avec des frameworks d'apprentissage automatique basés sur python (PyTorch, Tensorflow, etc.).
Recommended Posts