diff options
Diffstat (limited to 'python-ptpt.spec')
| -rw-r--r-- | python-ptpt.spec | 613 |
1 files changed, 613 insertions, 0 deletions
diff --git a/python-ptpt.spec b/python-ptpt.spec new file mode 100644 index 0000000..4120f07 --- /dev/null +++ b/python-ptpt.spec @@ -0,0 +1,613 @@ +%global _empty_manifest_terminate_build 0 +Name: python-ptpt +Version: 0.0.28 +Release: 1 +Summary: PyTorch Personal Trainer: My personal framework for deep learning experiments +License: MIT License +URL: https://github.com/vvvm23/ptpt +Source0: https://mirrors.nju.edu.cn/pypi/web/packages/8b/a1/6d4ddf75f32336d49d8507c4d6aca821516486168c4602cc0b7f4ec8e9f6/ptpt-0.0.28.tar.gz +BuildArch: noarch + +Requires: python3-torch +Requires: python3-rich +Requires: python3-wandb +Requires: python3-accelerate + +%description +# Alex's PyTorch Personal Trainer (ptpt) +> (name subject to change) + +This repository contains my personal lightweight framework for deep learning +projects in PyTorch. + +> **Disclaimer: this project is very much work-in-progress. Although technically +> useable, it is missing many features. Nonetheless, you may find some of the +> design patterns and code snippets to be useful in the meantime.** + +## Installation + +Install from `pip` by running `pip install ptpt` + +You can also build from source. Simply run `python -m build` in the root of the +repo, then run `pip install` on the resulting `.whl` file. + +## Usage +Import the library as with any other python library: +```python +from ptpt.trainer import Trainer, TrainerConfig +from ptpt.log import debug, info, warning, error, critical +``` + +The core of the library is the `trainer.Trainer` class. In the simplest case, +it takes the following as input: + +```python +net: a `nn.Module` that is the model we wish to train. +loss_fn: a function that takes a `nn.Module` and a batch as input. + it returns the loss and optionally other metrics. +train_dataset: the training dataset. +test_dataset: the test dataset. +cfg: a `TrainerConfig` instance that holds all + hyperparameters. +``` + +Once this is instantiated, starting the training loop is as simple as calling +`trainer.train()` where `trainer` is an instance of `Trainer`. + +`cfg` stores most of the configuration options for `Trainer`. See the class +definition of `TrainerConfig` for details on all options. + +## Examples + +An example workflow would go like this: + +> Define your training and test datasets: + +```python +transform=transforms.Compose([ + transforms.ToTensor(), + transforms.Normalize((0.1307,), (0.3081,)) +]) +train_dataset = datasets.MNIST('../data', train=True, download=True, transform=transform) +test_dataset = datasets.MNIST('../data', train=False, download=True, transform=transform) +``` + +> Define your model: + +```python +# `Net` could be any `nn.Module` +net = Net() +``` + +> Define your loss function that calls `net`, taking the full batch as input: + +```python +# minimising classification error +def loss_fn(net, batch): + X, y = batch + logits = net(X) + loss = F.nll_loss(logits, y) + + pred = logits.argmax(dim=-1, keepdim=True) + accuracy = 100. * pred.eq(y.view_as(pred)).sum().item() / y.shape[0] + return loss, accuracy +``` + +> Optionally create a configuration object: + +```python +# see class definition for full list of parameters +cfg = TrainerConfig( + exp_name = 'mnist-conv', + batch_size = 64, + learning_rate = 4e-4, + nb_workers = 4, + save_outputs = False, + metric_names = ['accuracy'] +) +``` + +> Initialise the Trainer class: + +```python +trainer = Trainer( + net=net, + loss_fn=loss_fn, + train_dataset=train_dataset, + test_dataset=test_dataset, + cfg=cfg +) +``` + +> Optionally, register some callback functions: + +```python +def callback_fn(_): + info("Congratulations, you have completed an epoch!") +trainer.register_callback(CallbackType.TrainEpoch, callback_fn) +``` + +> Call `trainer.train()` to begin the training loop + +```python +trainer.train() # Go! +``` + +See more examples [here](examples/). + +#### Weights and Biases Integration + +Weights and Biases logging is supported via the `ptpt.wandb.WandConfig` +dataclass. + +Currently only supports a small set of features: +``` +class WandbConfig: + project: str = None # project name + entity: str = None # wandb entity name + name: str = None # run name (leave blank for random two words) + config: dict = None # hyperparameters to save on wandb + log_net: bool = False # whether to use wandb to watch network gradients + log_metrics: bool = True # whether to use wandb to report epoch metrics +``` + +If you want to log something else in addition to epoch metrics, you can use +`ptpt.callbacks` and access wandb through `trainer.wandb`. When calling log +here, ensure commit is set to `False` to avoid advancing the global step. + +## Motivation +I found myself repeating a lot of same structure in many of my deep learning +projects. This project is the culmination of my efforts refining the typical +structure of my projects into (what I hope to be) a wholly reusable and +general-purpose library. + +Additionally, there are many nice theoretical and engineering tricks that +are available to deep learning researchers. Unfortunately, a lot of them are +forgotten because they fall outside the typical workflow, despite them being +very beneficial to include. Another goal of this project is to transparently +include these tricks so they can be added and removed with minimal code change. +Where it is sane to do so, some of these could be on by default. + +Finally, I am guilty of forgetting to implement decent logging: both of +standard output and of metrics. Logging of standard output is not hard, and +is implemented using other libraries such as [rich](https://github.com/willmcgugan/rich). +However, metric logging is less obvious. I'd like to avoid larger dependencies +such as tensorboard being an integral part of the project, so metrics will be +logged to simple numpy arrays. The library will then provide functions to +produce plots from these, or they can be used in another library. + +### TODO: + +- [X] Add arbitrary callback support at various points of execution +- [X] Add metric tracking +- [ ] Add more learning rate schedulers +- [ ] Add more optimizer options +- [ ] Add logging-to-file +- [ ] Adds silent and simpler logging +- [ ] Support for distributed / multi-GPU operations +- [ ] Set of functions for producing visualisations from disk dumps +- [ ] General suite of useful functions + +### References +- [rich](https://github.com/willmcgugan/rich) by [@willmcgugan](https://github.com/willmcgugan) + +### Citations + + + +%package -n python3-ptpt +Summary: PyTorch Personal Trainer: My personal framework for deep learning experiments +Provides: python-ptpt +BuildRequires: python3-devel +BuildRequires: python3-setuptools +BuildRequires: python3-pip +%description -n python3-ptpt +# Alex's PyTorch Personal Trainer (ptpt) +> (name subject to change) + +This repository contains my personal lightweight framework for deep learning +projects in PyTorch. + +> **Disclaimer: this project is very much work-in-progress. Although technically +> useable, it is missing many features. Nonetheless, you may find some of the +> design patterns and code snippets to be useful in the meantime.** + +## Installation + +Install from `pip` by running `pip install ptpt` + +You can also build from source. Simply run `python -m build` in the root of the +repo, then run `pip install` on the resulting `.whl` file. + +## Usage +Import the library as with any other python library: +```python +from ptpt.trainer import Trainer, TrainerConfig +from ptpt.log import debug, info, warning, error, critical +``` + +The core of the library is the `trainer.Trainer` class. In the simplest case, +it takes the following as input: + +```python +net: a `nn.Module` that is the model we wish to train. +loss_fn: a function that takes a `nn.Module` and a batch as input. + it returns the loss and optionally other metrics. +train_dataset: the training dataset. +test_dataset: the test dataset. +cfg: a `TrainerConfig` instance that holds all + hyperparameters. +``` + +Once this is instantiated, starting the training loop is as simple as calling +`trainer.train()` where `trainer` is an instance of `Trainer`. + +`cfg` stores most of the configuration options for `Trainer`. See the class +definition of `TrainerConfig` for details on all options. + +## Examples + +An example workflow would go like this: + +> Define your training and test datasets: + +```python +transform=transforms.Compose([ + transforms.ToTensor(), + transforms.Normalize((0.1307,), (0.3081,)) +]) +train_dataset = datasets.MNIST('../data', train=True, download=True, transform=transform) +test_dataset = datasets.MNIST('../data', train=False, download=True, transform=transform) +``` + +> Define your model: + +```python +# `Net` could be any `nn.Module` +net = Net() +``` + +> Define your loss function that calls `net`, taking the full batch as input: + +```python +# minimising classification error +def loss_fn(net, batch): + X, y = batch + logits = net(X) + loss = F.nll_loss(logits, y) + + pred = logits.argmax(dim=-1, keepdim=True) + accuracy = 100. * pred.eq(y.view_as(pred)).sum().item() / y.shape[0] + return loss, accuracy +``` + +> Optionally create a configuration object: + +```python +# see class definition for full list of parameters +cfg = TrainerConfig( + exp_name = 'mnist-conv', + batch_size = 64, + learning_rate = 4e-4, + nb_workers = 4, + save_outputs = False, + metric_names = ['accuracy'] +) +``` + +> Initialise the Trainer class: + +```python +trainer = Trainer( + net=net, + loss_fn=loss_fn, + train_dataset=train_dataset, + test_dataset=test_dataset, + cfg=cfg +) +``` + +> Optionally, register some callback functions: + +```python +def callback_fn(_): + info("Congratulations, you have completed an epoch!") +trainer.register_callback(CallbackType.TrainEpoch, callback_fn) +``` + +> Call `trainer.train()` to begin the training loop + +```python +trainer.train() # Go! +``` + +See more examples [here](examples/). + +#### Weights and Biases Integration + +Weights and Biases logging is supported via the `ptpt.wandb.WandConfig` +dataclass. + +Currently only supports a small set of features: +``` +class WandbConfig: + project: str = None # project name + entity: str = None # wandb entity name + name: str = None # run name (leave blank for random two words) + config: dict = None # hyperparameters to save on wandb + log_net: bool = False # whether to use wandb to watch network gradients + log_metrics: bool = True # whether to use wandb to report epoch metrics +``` + +If you want to log something else in addition to epoch metrics, you can use +`ptpt.callbacks` and access wandb through `trainer.wandb`. When calling log +here, ensure commit is set to `False` to avoid advancing the global step. + +## Motivation +I found myself repeating a lot of same structure in many of my deep learning +projects. This project is the culmination of my efforts refining the typical +structure of my projects into (what I hope to be) a wholly reusable and +general-purpose library. + +Additionally, there are many nice theoretical and engineering tricks that +are available to deep learning researchers. Unfortunately, a lot of them are +forgotten because they fall outside the typical workflow, despite them being +very beneficial to include. Another goal of this project is to transparently +include these tricks so they can be added and removed with minimal code change. +Where it is sane to do so, some of these could be on by default. + +Finally, I am guilty of forgetting to implement decent logging: both of +standard output and of metrics. Logging of standard output is not hard, and +is implemented using other libraries such as [rich](https://github.com/willmcgugan/rich). +However, metric logging is less obvious. I'd like to avoid larger dependencies +such as tensorboard being an integral part of the project, so metrics will be +logged to simple numpy arrays. The library will then provide functions to +produce plots from these, or they can be used in another library. + +### TODO: + +- [X] Add arbitrary callback support at various points of execution +- [X] Add metric tracking +- [ ] Add more learning rate schedulers +- [ ] Add more optimizer options +- [ ] Add logging-to-file +- [ ] Adds silent and simpler logging +- [ ] Support for distributed / multi-GPU operations +- [ ] Set of functions for producing visualisations from disk dumps +- [ ] General suite of useful functions + +### References +- [rich](https://github.com/willmcgugan/rich) by [@willmcgugan](https://github.com/willmcgugan) + +### Citations + + + +%package help +Summary: Development documents and examples for ptpt +Provides: python3-ptpt-doc +%description help +# Alex's PyTorch Personal Trainer (ptpt) +> (name subject to change) + +This repository contains my personal lightweight framework for deep learning +projects in PyTorch. + +> **Disclaimer: this project is very much work-in-progress. Although technically +> useable, it is missing many features. Nonetheless, you may find some of the +> design patterns and code snippets to be useful in the meantime.** + +## Installation + +Install from `pip` by running `pip install ptpt` + +You can also build from source. Simply run `python -m build` in the root of the +repo, then run `pip install` on the resulting `.whl` file. + +## Usage +Import the library as with any other python library: +```python +from ptpt.trainer import Trainer, TrainerConfig +from ptpt.log import debug, info, warning, error, critical +``` + +The core of the library is the `trainer.Trainer` class. In the simplest case, +it takes the following as input: + +```python +net: a `nn.Module` that is the model we wish to train. +loss_fn: a function that takes a `nn.Module` and a batch as input. + it returns the loss and optionally other metrics. +train_dataset: the training dataset. +test_dataset: the test dataset. +cfg: a `TrainerConfig` instance that holds all + hyperparameters. +``` + +Once this is instantiated, starting the training loop is as simple as calling +`trainer.train()` where `trainer` is an instance of `Trainer`. + +`cfg` stores most of the configuration options for `Trainer`. See the class +definition of `TrainerConfig` for details on all options. + +## Examples + +An example workflow would go like this: + +> Define your training and test datasets: + +```python +transform=transforms.Compose([ + transforms.ToTensor(), + transforms.Normalize((0.1307,), (0.3081,)) +]) +train_dataset = datasets.MNIST('../data', train=True, download=True, transform=transform) +test_dataset = datasets.MNIST('../data', train=False, download=True, transform=transform) +``` + +> Define your model: + +```python +# `Net` could be any `nn.Module` +net = Net() +``` + +> Define your loss function that calls `net`, taking the full batch as input: + +```python +# minimising classification error +def loss_fn(net, batch): + X, y = batch + logits = net(X) + loss = F.nll_loss(logits, y) + + pred = logits.argmax(dim=-1, keepdim=True) + accuracy = 100. * pred.eq(y.view_as(pred)).sum().item() / y.shape[0] + return loss, accuracy +``` + +> Optionally create a configuration object: + +```python +# see class definition for full list of parameters +cfg = TrainerConfig( + exp_name = 'mnist-conv', + batch_size = 64, + learning_rate = 4e-4, + nb_workers = 4, + save_outputs = False, + metric_names = ['accuracy'] +) +``` + +> Initialise the Trainer class: + +```python +trainer = Trainer( + net=net, + loss_fn=loss_fn, + train_dataset=train_dataset, + test_dataset=test_dataset, + cfg=cfg +) +``` + +> Optionally, register some callback functions: + +```python +def callback_fn(_): + info("Congratulations, you have completed an epoch!") +trainer.register_callback(CallbackType.TrainEpoch, callback_fn) +``` + +> Call `trainer.train()` to begin the training loop + +```python +trainer.train() # Go! +``` + +See more examples [here](examples/). + +#### Weights and Biases Integration + +Weights and Biases logging is supported via the `ptpt.wandb.WandConfig` +dataclass. + +Currently only supports a small set of features: +``` +class WandbConfig: + project: str = None # project name + entity: str = None # wandb entity name + name: str = None # run name (leave blank for random two words) + config: dict = None # hyperparameters to save on wandb + log_net: bool = False # whether to use wandb to watch network gradients + log_metrics: bool = True # whether to use wandb to report epoch metrics +``` + +If you want to log something else in addition to epoch metrics, you can use +`ptpt.callbacks` and access wandb through `trainer.wandb`. When calling log +here, ensure commit is set to `False` to avoid advancing the global step. + +## Motivation +I found myself repeating a lot of same structure in many of my deep learning +projects. This project is the culmination of my efforts refining the typical +structure of my projects into (what I hope to be) a wholly reusable and +general-purpose library. + +Additionally, there are many nice theoretical and engineering tricks that +are available to deep learning researchers. Unfortunately, a lot of them are +forgotten because they fall outside the typical workflow, despite them being +very beneficial to include. Another goal of this project is to transparently +include these tricks so they can be added and removed with minimal code change. +Where it is sane to do so, some of these could be on by default. + +Finally, I am guilty of forgetting to implement decent logging: both of +standard output and of metrics. Logging of standard output is not hard, and +is implemented using other libraries such as [rich](https://github.com/willmcgugan/rich). +However, metric logging is less obvious. I'd like to avoid larger dependencies +such as tensorboard being an integral part of the project, so metrics will be +logged to simple numpy arrays. The library will then provide functions to +produce plots from these, or they can be used in another library. + +### TODO: + +- [X] Add arbitrary callback support at various points of execution +- [X] Add metric tracking +- [ ] Add more learning rate schedulers +- [ ] Add more optimizer options +- [ ] Add logging-to-file +- [ ] Adds silent and simpler logging +- [ ] Support for distributed / multi-GPU operations +- [ ] Set of functions for producing visualisations from disk dumps +- [ ] General suite of useful functions + +### References +- [rich](https://github.com/willmcgugan/rich) by [@willmcgugan](https://github.com/willmcgugan) + +### Citations + + + +%prep +%autosetup -n ptpt-0.0.28 + +%build +%py3_build + +%install +%py3_install +install -d -m755 %{buildroot}/%{_pkgdocdir} +if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi +if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi +if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi +if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi +pushd %{buildroot} +if [ -d usr/lib ]; then + find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/lib64 ]; then + find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/bin ]; then + find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/sbin ]; then + find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst +fi +touch doclist.lst +if [ -d usr/share/man ]; then + find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst +fi +popd +mv %{buildroot}/filelist.lst . +mv %{buildroot}/doclist.lst . + +%files -n python3-ptpt -f filelist.lst +%dir %{python3_sitelib}/* + +%files help -f doclist.lst +%{_docdir}/* + +%changelog +* Wed May 31 2023 Python_Bot <Python_Bot@openeuler.org> - 0.0.28-1 +- Package Spec generated |