learn2learn
ved dependency.
Learn2Learn ist eine Softwarebibliothek für Meta-Learning-Forschung.
Learn2learn Builds auf Pytorch, um zwei Aspekte des Meta-Learning-Forschungszyklus zu beschleunigen:
Learn2learn bietet Dienstprogramme und einheitliche Schnittstellen auf niedrige Ebene, um neue Algorithmen und Domänen sowie hochwertige Implementierungen vorhandener Algorithmen und standardisierten Benchmarks zu erstellen. Es behält die Kompatibilität mit Torchvision, Torchaudio, Torchtext, Cherry und jeder anderen in Pytorch basierenden Bibliothek, die Sie möglicherweise verwenden, bei.
Weitere Informationen finden Sie in unserem Whitepaper: Arxiv: 2008.12284
Überblick
learn2learn.data : Taskset und transformiert, um nur wenige Aufgaben aus jedem Pytorch-Datensatz zu erstellen.learn2learn.vision : Modelle, Datensätze und Benchmarks für Computer Vision und wenige Lernen.learn2learn.gym : Umwelt und Versorgungsunternehmen für das Lernen von Meta-Verstärkung.learn2learn.algorithms : Hochstufe Wrapper für vorhandene Meta-Learning-Algorithmen.learn2learn.optim : Dienstprogramme und Algorithmen für differenzierbare Optimierung und Meta-Dezent.Ressourcen
pip install learn2learnDie folgenden Ausschnitte bieten einen kleinen Einblick in die Funktionen von Learn2learn.
Weitere Algorithmen (Protonetten, Anil, Meta-SGD, Reptile, Meta-Curvature, KFO) finden Sie in den Beispiel-Ordner. Die meisten von ihnen können mit dem GBML -Wrapper implementiert werden. (Dokumentation).
maml = l2l . algorithms . MAML ( model , lr = 0.1 )
opt = torch . optim . SGD ( maml . parameters (), lr = 0.001 )
for iteration in range ( 10 ):
opt . zero_grad ()
task_model = maml . clone () # torch.clone() for nn.Modules
adaptation_loss = compute_loss ( task_model )
task_model . adapt ( adaptation_loss ) # computes gradient, update task_model in-place
evaluation_loss = compute_loss ( task_model )
evaluation_loss . backward () # gradients w.r.t. maml.parameters()
opt . step () Erfahren Sie mit dem LearnableOptimizer jegliche Art von Optimierungsalgorithmus. (Beispiel und Dokumentation)
linear = nn . Linear ( 784 , 10 )
transform = l2l . optim . ModuleTransform ( l2l . nn . Scale )
metaopt = l2l . optim . LearnableOptimizer ( linear , transform , lr = 0.01 ) # metaopt has .step()
opt = torch . optim . SGD ( metaopt . parameters (), lr = 0.001 ) # metaopt also has .parameters()
metaopt . zero_grad ()
opt . zero_grad ()
error = loss ( linear ( X ), y )
error . backward ()
opt . step () # update metaopt
metaopt . step () # update linear Viele standardisierte Datensätze (Omniglot, Mini-/Tiered-Imagenet, FC100, CIFAR-FS) sind in learn2learn.vision.datasets leicht verfügbar. (Dokumentation)
dataset = l2l . data . MetaDataset ( MyDataset ()) # any PyTorch dataset
transforms = [ # Easy to define your own transform
l2l . data . transforms . NWays ( dataset , n = 5 ),
l2l . data . transforms . KShots ( dataset , k = 1 ),
l2l . data . transforms . LoadData ( dataset ),
]
taskset = Taskset ( dataset , transforms , num_tasks = 20000 )
for task in taskset :
X , y = task
# Meta-train on the task Parallel zu Ihren eigenen Meta-Umgebungen mit AsyncVectorEnv oder verwenden Sie die standardisierten. (Dokumentation)
def make_env ():
env = l2l . gym . HalfCheetahForwardBackwardEnv ()
env = cherry . envs . ActionSpaceScaler ( env )
return env
env = l2l . gym . AsyncVectorEnv ([ make_env for _ in range ( 16 )]) # uses 16 threads
for task_config in env . sample_tasks ( 20 ):
env . set_task ( task ) # all threads receive the same task
state = env . reset () # use standard Gym API
action = my_policy ( env )
env . step ( action )Lernen und differenzieren Sie durch Updates von Pytorch -Modulen. (Dokumentation)
model = MyModel ()
transform = l2l . optim . KroneckerTransform ( l2l . nn . KroneckerLinear )
learned_update = l2l . optim . ParameterUpdate ( # learnable update function
model . parameters (), transform )
clone = l2l . clone_module ( model ) # torch.clone() for nn.Modules
error = loss ( clone ( X ), y )
updates = learned_update ( # similar API as torch.autograd.grad
error ,
clone . parameters (),
create_graph = True ,
)
l2l . update_module ( clone , updates = updates )
loss ( clone ( X ), y ). backward () # Gradients w.r.t model.parameters() and learned_update.parameters() In der Datei chalchelog.md ist ein menschlicher lesbarer ChangeLog verfügbar.
Verwenden Sie die folgende Referenz, um das Repository learn2learn in Ihren akademischen Veröffentlichungen zu zitieren.
Arnold, Sebastien MR, Praateek Mahajan, Debajyoti Datta, Ian Bunner und Konstantinos Saitas Zarkias. 2020. "Learn2learn: Eine Bibliothek für Meta-Learning-Forschung." ARXIV [CS.LG]. http://arxiv.org/abs/2008.12284.
Sie können auch den folgenden Bibtex -Eintrag verwenden.
@article { Arnold2020-ss ,
title = " learn2learn: A Library for {Meta-Learning} Research " ,
author = " Arnold, S{'e}bastien M R and Mahajan, Praateek and Datta,
Debajyoti and Bunner, Ian and Zarkias, Konstantinos Saitas " ,
month = aug,
year = 2020 ,
url = " http://arxiv.org/abs/2008.12284 " ,
archivePrefix = " arXiv " ,
primaryClass = " cs.LG " ,
eprint = " 2008.12284 "
}
nn.Module als staatenlos sein, behält Learn2learn das staatliche Pytorch-Look-and-Feel bei. Weitere Informationen finden Sie in ihrem Arxiv -Papier.
