3 |
2 |
3 |
14 | Train off-the-shelf machine learning models in one line of code 15 |
16 | 17 |
18 | 
20 | 
21 | 
22 |
25 | Try it out in Google Colab • Documentation 26 |
27 | 28 | --- 29 | 30 | traintool is the easiest Python library for **applied machine learning**. It allows you 31 | to train off-the-shelf models with minimum code: Just give your data 32 | and the model name, and traintool takes care of the rest. It combines **pre-implemented 33 | models** (built on top of sklearn & pytorch) with powerful **utilities** that get you 34 | started in seconds (automatic visualizations, experiment tracking, intelligent data 35 | preprocessing, API deployment). 36 | 37 | 38 | Alpha Release: traintool is in an early alpha release. The API can and will change 39 | without notice. If you find a bug, please file an issue on 40 | [Github](https://github.com/jrieke/traintool) or 41 | [write me](mailto:johannes.rieke@gmail.com). 42 | 43 | 44 | 45 | 50 | 51 | 69 | 70 | 71 | ## Installation 72 | 73 | ```bash 74 | pip install traintool 75 | ``` 76 | 77 | 78 | ## Features 79 | 80 | - **Minimum coding —** traintool is designed to require as few lines of code as 81 | possible. It offers a sleek and intuitive interface that gets you started in seconds. 82 | Training a model just takes a single line: 83 | 84 | ```python 85 | traintool.train("resnet18", train_data, test_data, config={"optimizer": "adam", "lr": 0.1}) 86 | ``` 87 | 88 | - **Pre-implemented models —** The heart of traintool are fully implemented and tested 89 | models – from simple classifiers to deep neural networks; built on sklearn, pytorch, 90 | or tensorflow. Here are only a few of the models you can use: 91 | 92 | ```python 93 | "svc", "random-forest", "alexnet", "resnet50", "inception_v3", ... 94 | ``` 95 | 96 | - **Automatic visualizations & experiment tracking —** traintool automatically 97 | calculates metrics, creates beautiful visualizations (in 98 | [tensorboard](https://www.tensorflow.org/tensorboard) or 99 | [comet.ml](https://www.comet.ml/)), and stores experiment data and 100 | model checkpoints – without needing a single additional line of code. 101 | 102 | - **Ready for your data —** traintool understands numpy arrays, pytorch datasets, 103 | and files. It automatically converts and preprocesses everything based on the model you 104 | use. 105 | 106 | - **Instant deployment —** In one line of code, you can deploy your model to a REST 107 | API that you can query from anywhere. Just call: 108 | 109 | ```python 110 | model.deploy() 111 | ``` 112 | 113 | 114 | 123 | 124 | 125 | 126 | 127 | ## Example: Image classification on MNIST 128 | 129 | Run this example interactively in Google Colab: 130 | 131 | [](https://colab.research.google.com/github/jrieke/traintool/blob/master/docs/tutorial/quickstart.ipynb) 132 | 133 | ```python 134 | import mnist 135 | import traintool 136 | 137 | # Load MNIST data as numpy 138 | train_data = [mnist.train_images(), mnist.train_labels()] 139 | test_data = [mnist.test_images(), mnist.test_labels()] 140 | 141 | # Train SVM classifier 142 | svc = traintool.train("svc", train_data=train_data, test_data=test_data) 143 | 144 | # Train ResNet with custom hyperparameters 145 | resnet = traintool.train("resnet", train_data=train_data, test_data=test_data, 146 | config={"lr": 0.1, "optimizer": "adam"}) 147 | 148 | # Make prediction 149 | result = resnet.predict(test_data[0][0]) 150 | print(result["predicted_class"]) 151 | 152 | # Deploy to REST API 153 | resnet.deploy() 154 | 155 | # Get underlying pytorch model (e.g. for custom analysis) 156 | pytorch_model = resnet.raw()["model"] 157 | ``` 158 | 159 | For more information, check out the 160 | [complete tutorial](https://traintool.jrieke.com/tutorial/quickstart/). 161 | 162 | 163 | ## Get in touch! 164 | 165 | You have a question on traintool, want to use it in production, or miss a feature? I'm 166 | happy to hear from you! Write me at [johannes.rieke@gmail.com](mailto:johannes.rieke@gmail.com). 167 | -------------------------------------------------------------------------------- /docs/CNAME: -------------------------------------------------------------------------------- 1 | traintool.jrieke.com -------------------------------------------------------------------------------- /docs/assets/api.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jrieke/traintool/0ada1ff20a9a570be5cfb4ac21f3f914604c9833/docs/assets/api.png -------------------------------------------------------------------------------- /docs/assets/cover.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jrieke/traintool/0ada1ff20a9a570be5cfb4ac21f3f914604c9833/docs/assets/cover.png -------------------------------------------------------------------------------- /docs/assets/favicon.ico: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jrieke/traintool/0ada1ff20a9a570be5cfb4ac21f3f914604c9833/docs/assets/favicon.ico -------------------------------------------------------------------------------- /docs/assets/logo-white.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jrieke/traintool/0ada1ff20a9a570be5cfb4ac21f3f914604c9833/docs/assets/logo-white.png -------------------------------------------------------------------------------- /docs/index.md: -------------------------------------------------------------------------------- 1 |
2 | 
3 |
14 | Train off-the-shelf machine learning models in one line of code 15 |
16 | 17 |
18 |
20 |
21 |
22 |
25 | Try it out in Google Colab • Documentation 26 |
27 | 28 | --- 29 | 30 | traintool is the easiest Python library for **applied machine learning**. It allows you 31 | to train off-the-shelf models with minimum code: Just give your data 32 | and the model name, and traintool takes care of the rest. It combines **pre-implemented 33 | models** (built on top of sklearn & pytorch) with powerful **utilities** that get you 34 | started in seconds (automatic visualizations, experiment tracking, intelligent data 35 | preprocessing, API deployment). 36 | 37 | 38 | !!! warning "Alpha Release" 39 | traintool is in an early alpha release. The API can and will change 40 | without notice. If you find a bug, please file an issue on 41 | [Github](https://github.com/jrieke/traintool) or [write me](mailto:johannes.rieke@gmail.com). 42 | 43 | 44 | 45 | 50 | 51 | 69 | 70 | 71 | ## Installation 72 | 73 | ```bash 74 | pip install traintool 75 | ``` 76 | 77 | 78 | 79 | ## Features 80 | 81 | - **Minimum coding —** traintool is designed to require as few lines of code as 82 | possible. It offers a sleek and intuitive interface that gets you started in seconds. 83 | Training a model just takes a single line: 84 | 85 | traintool.train("resnet18", train_data, test_data, config={"optimizer": "adam", "lr": 0.1}) 86 | 87 | 88 | - **Pre-implemented models —** The heart of traintool are fully implemented and tested 89 | models – from simple classifiers to deep neural networks; built on sklearn, pytorch, 90 | or tensorflow. Here are only a few of the models you can use: 91 | 92 | "svc", "random-forest", "alexnet", "resnet50", "inception_v3", ... 93 | 94 | - **Automatic visualizations & experiment tracking —** traintool automatically 95 | calculates metrics, creates beautiful visualizations (in 96 | [tensorboard](https://www.tensorflow.org/tensorboard) or 97 | [comet.ml](https://www.comet.ml/)), and stores experiment data and 98 | model checkpoints – without needing a single additional line of code. 99 | 100 | - **Ready for your data —** traintool understands numpy arrays, pytorch datasets, 101 | and files. It automatically converts and preprocesses everything based on the model you 102 | use. 103 | 104 | - **Instant deployment —** In one line of code, you can deploy your model to a REST 105 | API that you can query from anywhere. Just call: 106 | 107 | model.deploy() 108 | 109 | 110 | 119 | 120 | 121 | ## Example: Image classification on MNIST 122 | 123 | Run this example interactively in Google Colab: 124 | 125 | [](https://colab.research.google.com/github/jrieke/traintool/blob/master/docs/tutorial/quickstart.ipynb) 126 | 127 | ```python 128 | import mnist 129 | import traintool 130 | 131 | # Load MNIST data as numpy 132 | train_data = [mnist.train_images(), mnist.train_labels()] 133 | test_data = [mnist.test_images(), mnist.test_labels()] 134 | 135 | # Train SVM classifier 136 | svc = traintool.train("svc", train_data=train_data, test_data=test_data) 137 | 138 | # Train ResNet with custom hyperparameters 139 | resnet = traintool.train("resnet", train_data=train_data, test_data=test_data, 140 | config={"lr": 0.1, "optimizer": "adam"}) 141 | 142 | # Make prediction 143 | result = resnet.predict(test_data[0][0]) 144 | print(result["predicted_class"]) 145 | 146 | # Deploy to REST API 147 | resnet.deploy() 148 | 149 | # Get underlying pytorch model (e.g. for custom analysis) 150 | pytorch_model = resnet.raw()["model"] 151 | ``` 152 | 153 | For more information, check out the 154 | [complete tutorial](https://traintool.jrieke.com/tutorial/quickstart/). 155 | 156 | 157 | ## Get in touch! 158 | 159 | You have a question on traintool, want to use it in production, or miss a feature? I'm 160 | happy to hear from you! Write me at [johannes.rieke@gmail.com](mailto:johannes.rieke@gmail.com). 161 | -------------------------------------------------------------------------------- /docs/models/image-classification.md: -------------------------------------------------------------------------------- 1 | # Image classification 2 | 3 |  4 | 5 | Image classification models classify an image into one out of several categories or 6 | classes, based on the image content (e.g. "cat" or "dog"). 7 | 8 | ## Input formats 9 | 10 | ### Numpy arrays 11 | 12 | Each data set should be a list of two elements: The first element is a numpy array 13 | of all images of shape `(number of images, color channels (1 or 3), height, width)`. The second 14 | element is an array of labels (as integer indices). 15 | 16 | Example: 17 | 18 | ```python 19 | train_images = np.zeros(32, 3, 256, 256) # 32 images with 3 color channels and size 256x256 20 | train_labels = np.zeros(32, dtype=int) 21 | 22 | traintool.train(..., train_data=[train_images, train_labels]) 23 | ``` 24 | 25 | 33 | 34 | ### Files 35 | 36 | Image files should be arranged in one folder per class, similar to this: 37 | 38 | ``` 39 | train 40 | +-- dogs 41 | | +-- funny-dog.jpg 42 | | +-- another-dog.png 43 | +-- cats 44 | | +-- brown-cat.png 45 | | +-- black-cat.png 46 | ... 47 | ``` 48 | 49 | Then simply pass the directory path to the `train` function: 50 | 51 | ```python 52 | traintool.train(..., train_data="./train") 53 | ``` 54 | 55 | 56 | ## Scikit-learn models 57 | 58 | These models implement simple classification algorithms that should train in a 59 | reasonable amount of time. Note that they are not GPU-accelerated so they might still 60 | take quite long with large datasets. 61 | 62 | **Preprocessing:** Image files are first loaded to a size of 28 x 28. All images (numpy 63 | or files) are then flattened and scaled to mean 0, standard deviation 1 (based on the 64 | train set). 65 | 66 | **Config parameters:** 67 | 68 | - `num_samples`: Set the number of samples to train on. This can be used to train on a 69 | subset of the data. Defaults to None (i.e. train on all data). 70 | - `num_samples_to_plot`: Set the number of samples to plot to tensorboard for each 71 | dataset. Defaults to 5. 72 | - All other config parameters are forwarded to the constructor of the sklearn object 73 | 74 | **Models:** 75 | 76 | - `random-forest`: A random forest classifier, from [sklearn.ensemble.RandomForestClassifier](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html) 77 | - `gradient-boosting`: Gradient boosting for classification, from [sklearn.ensemble.GradientBoostingClassifier](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.GradientBoostingClassifier.html) 78 | - `gaussian-process`: Gaussian process classification based on Laplace approximation, from [sklearn.gaussian_process.GaussianProcessClassifier](https://scikit-learn.org/stable/modules/generated/sklearn.gaussian_process.GaussianProcessClassifier.html#sklearn.gaussian_process.GaussianProcessClassifier) 79 | - `logistic-regression`: Logistic Regression (aka logit, MaxEnt) classifier, from [sklearn.linear_model.LogisticRegression](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html) 80 | - `sgd`: Linear classifiers (SVM, logistic regression, etc.) with SGD training, from [sklearn.linear_model.SGDClassifier](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.SGDClassifier.html) 81 | - `perceptron`: A perceptron classifier, from [sklearn.linear_model.Perceptron](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.Perceptron.html) 82 | - `passive-aggressive`: Passive aggressive classifier, from [sklearn.linear_model.PassiveAggressiveClassifier](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.PassiveAggressiveClassifier.html) 83 | - `gaussian-nb`: Gaussian Naive Bayes, from [sklearn.naive_bayes.GaussianNB](https://scikit-learn.org/stable/modules/generated/sklearn.naive_bayes.GaussianNB.html) 84 | - `k-neighbors`: Classifier implementing the k-nearest neighbors vote, from [sklearn.neighbors.KNeighborsClassifier](https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.html) 85 | - `mlp`: Multi-layer Perceptron classifier, from [sklearn.neural_network.MLPClassifier](https://scikit-learn.org/stable/modules/generated/sklearn.neural_network.MLPClassifier.html) 86 | - `svc`: C-Support Vector Classification, from [sklearn.svm.SVC](https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html) 87 | - `linear-svc`: Linear Support Vector Classification, from [sklearn.svm.LinearSVC](https://scikit-learn.org/stable/modules/generated/sklearn.svm.LinearSVC.html) 88 | - `decision-tree`: A decision tree classifier, from [sklearn.tree.DecisionTreeClassifier](https://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeClassifier.html) 89 | - `extra-tree`: An extra-trees classifier, from [sklearn.ensemble.ExtraTreesClassifier](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.ExtraTreesClassifier.html) 90 | 91 | 92 | 93 | ## PyTorch models 94 | 95 | These models implement deep neural networks that can give better results on complex 96 | datasets. They are GPU-accelerated if run on a machine with a GPU. 97 | 98 | **Preprocessing:** All images (numpy or files) are rescaled to 256 x 256, then 99 | center-cropped to 224 x 224, MEAN STD 100 | 101 | **Config parameters:** 102 | 103 | - `num_classes`: The number of classes/different output labels (and therefore number of 104 | output neurons of the network). Defaults to None, in which case it will be automatically 105 | inferred from the data. 106 | - `num_samples`: Set the number of samples to train on. This can be used to train on a 107 | subset of the data. Defaults to None (i.e. train on all data). 108 | - `num_samples_to_plot`: Set the number of samples to plot to tensorboard for each 109 | dataset. Defaults to 5. 110 | - `pretrained`: Whether to use pretrained weights for the models (trained on ImageNet). 111 | Note that this requires that there are 1000 classes (the ImageNet classes). Defaults to 112 | False. 113 | 114 | **Models:** 115 | 116 | More information on the [torchvision docs](https://pytorch.org/docs/stable/torchvision/models.html). 117 | 118 | - `alexnet`: AlexNet model architecture from the [“One weird trick…”](https://arxiv.org/abs/1404.5997) paper 119 | - `vgg11`, `vgg11_bn`, `vgg13`, `vgg13_bn`, `vgg16`, `vgg16_bn`, `vgg19`, or `vgg19_bn`: VGG model variants from [“Very Deep Convolutional Networks For Large-Scale Image Recognition”](https://arxiv.org/pdf/1409.1556.pdf) 120 | - `resnet18`, `resnet34`, `resnet50`, `resnet101`, or `resnet152`: ResNet model variants from [“Deep Residual Learning for Image Recognition”](https://arxiv.org/pdf/1512.03385.pdf) 121 | - `squeezenet1_0`, or `squeezenet1_1`: SqueezeNet model variants from the [“SqueezeNet: AlexNet-level accuracy with 50x fewer parameters and <0.5MB model size”](https://arxiv.org/abs/1602.07360) paper. 122 | - `densenet121`, `densenet169`, `densenet161`, or `densenet201`: Densenet model variants from [“Densely Connected Convolutional Networks”](https://arxiv.org/pdf/1608.06993.pdf) 123 | - `inception_v3`: Inception v3 model architecture from [“Rethinking the Inception Architecture for Computer Vision”](http://arxiv.org/abs/1512.00567) 124 | - `googlenet`: GoogLeNet (Inception v1) model architecture from [“Going Deeper with Convolutions”](http://arxiv.org/abs/1409.4842) 125 | - `shufflenet_v2_x0_5`, `shufflenet_v2_x1_0`, `shufflenet_v2_x1_5`, or `shufflenet_v2_x2_0`: ShuffleNetV2 variants, as described in [“ShuffleNet V2: Practical Guidelines for Efficient CNN Architecture Design”](https://arxiv.org/abs/1807.11164) 126 | - `mobilenet_v2`: MobileNetV2 architecture from [“MobileNetV2: Inverted Residuals and Linear Bottlenecks”](https://arxiv.org/abs/1801.04381) 127 | - `resnext50_32x4d` or `resnext101_32x8d`: ResNeXt model variants from [“Aggregated Residual Transformation for Deep Neural Networks”](https://arxiv.org/pdf/1611.05431.pdf) 128 | - `wide_resnet50_2` or `wide_resnet101_2`: Wide ResNet-50-2 model variants from [“Wide Residual Networks”](https://arxiv.org/pdf/1605.07146.pdf) 129 | - `mnasnet0_5`, `mnasnet0_75`, `mnasnet1_0`, or `mnasnet1_3`: MNASNet variants from [“MnasNet: Platform-Aware Neural Architecture Search for Mobile”](https://arxiv.org/pdf/1807.11626.pdf) 130 | 131 | 132 | -------------------------------------------------------------------------------- /docs/models/object-detection.md: -------------------------------------------------------------------------------- 1 | # Object detection 2 | 3 | Coming soon! -------------------------------------------------------------------------------- /docs/models/text-classification.md: -------------------------------------------------------------------------------- 1 | # Text classification 2 | 3 | Coming soon! -------------------------------------------------------------------------------- /docs/requirements.txt: -------------------------------------------------------------------------------- 1 | mkdocs 2 | mkdocs-material 3 | pygments 4 | pymdown-extensions 5 | mkdocs-autolinks-plugin 6 | mknotebooks 7 | #mkdocs-table-reader-plugin 8 | #mkdocs-jupyter # NOTE: this requires nbconvert==5.6.1 9 | #mkdocs-exclude 10 | #mkdocs-click 11 | #mkdocstrings 12 | -------------------------------------------------------------------------------- /docs/stylesheets/extra.css: -------------------------------------------------------------------------------- 1 | /* header different color*/ 2 | /* 3 | .md-header { 4 | background-color: #232f3e !important; 5 | border-bottom: 1px solid #1b2532 !important; 6 | } 7 | */ 8 | 9 | 10 | /* Active tab bold & color */ 11 | .md-tabs__link { 12 | font-size: .75rem !important; 13 | } 14 | .md-tabs__link--active { 15 | font-weight: bold !important; 16 | color: var(--md-accent-fg-color); 17 | } 18 | .md-tabs__link:hover { 19 | color: var(--md-accent-fg-color); 20 | } 21 | 22 | /* navigation bar active color*/ 23 | .md-nav__item .md-nav__link--active { 24 | font-weight: bold !important; 25 | color: var(--md-accent-fg-color); 26 | } 27 | .md-nav__item .md-nav__link--active { 28 | font-weight: bold !important; 29 | font-size: .75rem !important; 30 | color: var(--md-accent-fg-color); 31 | } 32 | 33 | /* frontpage elements */ 34 | .tx-hero h1 { 35 | font-size: 2.41rem !important; 36 | } 37 | a.md-button.md-button--primary { 38 | background-color: var(--md-accent-fg-color); 39 | border-color: var(--md-accent-fg-color); 40 | color: #ffffff; 41 | } 42 | a.md-button.md-button--primary:hover { 43 | color: #000000; 44 | } 45 | a.md-button.md-button:hover { 46 | color: #000000; 47 | } 48 | 49 | 50 | /* More visible headings*/ 51 | .md-main h1 { 52 | margin: 0.5em 0 1.0em 0; 53 | color: #333; 54 | font-weight: bold; 55 | font-size: 36px; 56 | line-height: 40px; 57 | /* 58 | counter-increment: section-1; 59 | counter-reset: section-2 section-3 section-4; 60 | */ 61 | } 62 | .md-main h2 { 63 | margin: 1.5em 0 0.4em 0; 64 | color: #595959; 65 | font-weight: normal; 66 | font-size: 30px; 67 | line-height: 36px; 68 | border-bottom: 1px solid #fff; 69 | box-shadow: 0 1px 0 rgba(0,0,0,0.1); 70 | padding-bottom: 10px; 71 | /* 72 | counter-increment: section-2; 73 | counter-reset: section-3 section-4; 74 | */ 75 | } 76 | .md-main h3 { 77 | margin: 1.2em 0 0.4em 0; 78 | color: #595959; 79 | font-weight: normal; 80 | font-size: 26px; 81 | line-height: 40px; 82 | /* 83 | counter-increment: section-3; 84 | counter-reset: section-4; 85 | */ 86 | } 87 | .md-main h4 { 88 | margin: 1.0em 0 0.4em 0; 89 | color: #333; 90 | font-weight: normal; 91 | font-size: 20px; 92 | line-height: 20px; 93 | /* counter-increment: section-4; */ 94 | } 95 | 96 | 97 | /* Define class for block image in block documentation trimmed*/ 98 | .blockimage { 99 | width: 200px; 100 | margin-right: 20px; 101 | margin-top: 7px; 102 | position:relative; 103 | float:left; 104 | } 105 | .blockimage img { 106 | width:100%; 107 | max-width:100%; 108 | float:left; 109 | } 110 | 111 | 112 | /*Table styling*/ 113 | table { 114 | padding: 0; } 115 | table tr { 116 | border-top: 1px solid #cccccc; 117 | background-color: white; 118 | margin: 0; 119 | padding: 0; } 120 | table tr:nth-child(2n) { 121 | background-color: #f8f8f8; } 122 | table tr th { 123 | font-weight: bold; 124 | border: 0px solid #cccccc; 125 | text-align: centre; 126 | margin: 0; 127 | padding: 6px 13px; } 128 | table tr td { 129 | border: 0px solid #cccccc; 130 | text-align: centre; 131 | margin: 0; 132 | padding: 6px 13px; } 133 | table tr th :first-child, table tr td :first-child { 134 | margin-top: 0; } 135 | table tr th :last-child, table tr td :last-child { 136 | margin-bottom: 0; } 137 | 138 | /*Neccessary css for tabbed extension*/ 139 | .tabbed-set { 140 | display: flex; 141 | position: relative; 142 | flex-wrap: wrap; 143 | } 144 | .tabbed-set .highlight { 145 | background: #ddd; 146 | } 147 | .tabbed-set .tabbed-content { 148 | display: none; 149 | order: 99; 150 | width: 100%; 151 | } 152 | .tabbed-set label { 153 | width: auto; 154 | margin: 0 0.5em; 155 | padding: 0.25em; 156 | font-size: 120%; 157 | cursor: pointer; 158 | } 159 | .tabbed-set input { 160 | position: absolute; 161 | opacity: 0; 162 | } 163 | .tabbed-set input:nth-child(n+1) { 164 | color: #333333; 165 | } 166 | .tabbed-set input:nth-child(n+1):checked + label { 167 | color: #FF5252; 168 | } 169 | .tabbed-set input:nth-child(n+1):checked + label + .tabbed-content { 170 | display: block; 171 | } 172 | 173 | 174 | /* Admonition settings option*/ 175 | .md-typeset .admonition.settings, .md-typeset details.settings { 176 | border-left: .22rem solid #448aff; 177 | } 178 | .md-typeset .admonition.settings>.admonition-title, .md-typeset details.settings>.admonition-title, .md-typeset details.settings>summary { 179 | border-bottom: .1rem solid rgba(236, 243, 255), .1); 180 | background-color: rgba(236, 243, 255), .1); 181 | } 182 | .md-typeset .admonition.settings>.admonition-title:before, .md-typeset details.settings>.admonition-title:before, .md-typeset details.settings>summary:before { 183 | color: #448aff; 184 | content: "settings"} 185 | 186 | 187 | /* Code block size, but then too small in blocks*/ 188 | /*code { font-size: 0.75em !important; }*/ 189 | 190 | 191 | /* Site width etc.*/ 192 | .md-grid { 193 | max-width: 64rem !important; 194 | } 195 | /* 196 | .framed-python{ 197 | margin-top:-70px; 198 | overflow:hidden; 199 | } 200 | .framed-r{ 201 | margin-top:0px; 202 | overflow:hidden; 203 | } 204 | .framed-r-api{ 205 | margin-top:-50px; 206 | overflow:hidden; 207 | } 208 | .framed-github{ 209 | height:100vh !important; 210 | width:100% !important; 211 | } 212 | */ 213 | 214 | 215 | /*Toc right margins*/ 216 | /* 217 | @media only screen and (min-width: 76.25em){ 218 | .framed-python{ 219 | margin-left:-45px; 220 | } 221 | .framed-r-api{ 222 | margin-left:-45px; 223 | } 224 | .md-sidebar--secondary { 225 | margin-left: 100% !important; 226 | } 227 | } 228 | */ 229 | 230 | 231 | /* mkdocstrings styling 232 | /* Indentation of function doc */ 233 | div.doc-contents:not(.first) { 234 | padding-left: 25px; 235 | border-left: 4px solid rgba(230, 230, 230); 236 | margin-bottom: 80px; 237 | } 238 | /* Don't capitalize names. */ 239 | h5.doc-heading { 240 | text-transform: none !important; 241 | } 242 | /* Don't use vertical space on hidden ToC entries. */ 243 | h6.hidden-toc { 244 | margin: 0 !important; 245 | position: relative; 246 | top: -70px; 247 | } 248 | h6.hidden-toc::before { 249 | margin-top: 0 !important; 250 | padding-top: 0 !important; 251 | } 252 | /* Don't show permalink of hidden ToC entries. */ 253 | h6.hidden-toc a.headerlink { 254 | display: none; 255 | } 256 | /* Avoid breaking parameters name, etc. in table cells. */ 257 | td code { 258 | word-break: normal !important; 259 | } 260 | /* For pieces of Markdown rendered in table cells. */ 261 | td p { 262 | margin-top: 0; 263 | margin-bottom: 0; 264 | } 265 | */ 266 | -------------------------------------------------------------------------------- /docs/stylesheets/extra.js: -------------------------------------------------------------------------------- 1 | 2 | /** 3 | 4 | // Table of contents always expanded 5 | document.addEventListener("DOMContentLoaded", function() { 6 | load_navpane(); 7 | }); 8 | 9 | function load_navpane() { 10 | var width = window.innerWidth; 11 | if (width <= 1200) { 12 | return; 13 | } 14 | 15 | var nav = document.getElementsByClassName("md-nav"); 16 | for(var i = 0; i < nav.length; i++) { 17 | if (typeof nav.item(i).style === "undefined") { 18 | continue; 19 | } 20 | 21 | if (nav.item(i).getAttribute("data-md-level") && nav.item(i).getAttribute("data-md-component")) { 22 | nav.item(i).style.display = 'block'; 23 | nav.item(i).style.overflow = 'visible'; 24 | } 25 | } 26 | 27 | var nav = document.getElementsByClassName("md-nav__toggle"); 28 | for(var i = 0; i < nav.length; i++) { 29 | nav.item(i).checked = true; 30 | } 31 | } 32 | **/ 33 | 34 | 35 | // Open links externally. 36 | var links = document.links; 37 | 38 | for (var i = 0, linksLength = links.length; i < linksLength; i++) { 39 | if (links[i].hostname != window.location.hostname) { 40 | links[i].target = '_blank'; 41 | } 42 | } -------------------------------------------------------------------------------- /docs/tutorial/deployment.md: -------------------------------------------------------------------------------- 1 | # Deployment 2 | 3 | traintool can easily deploy your model through a REST API. This allows you to access the model from a website or application without shipping it with your code. 4 | 5 | Deployment uses [FastAPI](https://fastapi.tiangolo.com/) under the hood, which makes the API fully compatible with [OpenAPI/Swagger](https://github.com/OAI/OpenAPI-Specification) and [JSON Schema](http://json-schema.org/). 6 | 7 | 8 | ## Deploying a model 9 | 10 | To deploy a model after training or loading, simply run: 11 | 12 | ```python 13 | model.deploy() 14 | ``` 15 | 16 | Note that the call to `deploy` is blocking, i.e. it should be run in a separate script. Also, it might not work well with Jupyter notebooks. 17 | 18 | !!! tip 19 | By default, the API will run on 127.0.0.1 at port 8000, but you can modify this, e.g. `model.deploy(host=0.0.0.0, port=8001)`. 20 | 21 | 22 | ## Accessing the API 23 | 24 | To access the API, navigate your browser to http://127.0.0.1:8000/. If everything worked out, you should see some basic information about the deployed model like below: 25 | 26 |  27 | 28 | To find out more about the API, check out the API docs at http://127.0.0.1:8000/docs. They contain information about all endpoints and required data types. 29 | 30 | 31 | ## Making predictions 32 | 33 | If you want to make a prediction with the API, you need to make a POST request to the `/predict` endpoint (http://127.0.0.1:8000/predict). The request body should look like this: 34 | 35 | ```json 36 | { 37 | "image": [[[0, 0.5, 0, 1], [0, 1, 0, 0.5]]] 38 | } 39 | ``` 40 | 41 | 42 | `"image"` is a list of lists with shape `color channels x height x width`(here: a grayscale 4x4 image). You can easily get this list format from a numpy array with [numpy.ndarray.tolist](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.tolist.html). Note that you cannot pass raw numpy arrays into the request because they are not JSON serializable. 43 | 44 | As in training, images can be RGB (3 color channels) or grayscale (1 color channel). They will be automatically preprocessed in the same way as the train data. If you used numpy images for training, make sure the image here has the same size and pixel range. If you used files, everything should be converted to the correct format automatically. 45 | 46 | !!! tip 47 | You can easily try out the `/predict` endpoint if you go to the API docs (http://127.0.0.1:8000/docs), click on `/predict` and then on the "Try it out" button on the right. 48 | 49 | The endpoint will return a JSON object which is very similar to the dictionary returned by `model.predict(...)`. Numpy arrays are again converted to lists of lists (convert back with [numpy.asarray](https://numpy.org/doc/stable/reference/generated/numpy.asarray.html)). The JSON should look like this: 50 | 51 | ```json 52 | { 53 | "predicted_class": 2, 54 | "probabilities": [ 55 | 0.1, 56 | 0.8, 57 | 0.1 58 | ], 59 | "runtime": "0:00:00.088831" 60 | } 61 | ``` 62 | 63 | 64 | 65 | 66 | -------------------------------------------------------------------------------- /docs/tutorial/experiment-tracking.md: -------------------------------------------------------------------------------- 1 | # Experiment tracking 2 | 3 | traintool tracks common metrics automatically (e.g. accuracy on train and test set) 4 | and has different options to store and visualize them. 5 | 6 | 7 | ## Tensorboard 8 | 9 | [Tensorboard](https://www.tensorflow.org/tensorboard) is a popular visualization toolkit from Google's tensorflow framework. By default, traintool automatically stores logs for tensorboard along with the model, so that you can visualize the metrics of your experiments. 10 | 11 | To start tensorboard, run on your terminal (from the project dir): 12 | 13 | ```bash 14 | tensorboard --logdir traintool-experiments 15 | ``` 16 | 17 | Navigate your browser to [http://localhost:6006/](http://localhost:6006/) and you should see the tensorboard window: 18 | 19 | INSERT IMAGE HERE 20 | 21 | On the bottom left, you can select all the different runs (same names as the directories in `traintool-experiments`), on the right side you can view the metrics. 22 | 23 | 24 | 25 | ## Comet.ml 26 | 27 | You can store these metrics in [comet.ml](https://www.comet.ml/), a popular platform 28 | for experiment tracking. They offer free accounts (you can sign up with your Github 29 | account), and free premium for students & academia. 30 | 31 | Once you have your account, log in to comet.ml, click on your profile in the upper 32 | right corner, go on settings and on "Generate API Key". Pass this API key along to the 33 | `train` function like this: 34 | 35 | ```python 36 | traintool.train("resnet", train_data=train_data, test_data=test_data, 37 | comet_config={"api_key": YOUR_API_KEY, "project_name": OPTIONAL_PROJECT_NAME}) 38 | ``` 39 | 40 | Now you can head on over to [comet.ml](https://www.comet.ml/) and follow the metrics in 41 | real time! 42 | 43 | -------------------------------------------------------------------------------- /docs/tutorial/intro.md: -------------------------------------------------------------------------------- 1 | # Intro 2 | 3 | This tutorial shows you everything that **traintool** can do. 4 | 5 | We will train a few different models on MNIST, use automated experiment tracking, deploy 6 | the models via REST APIs, and get access to the underlying, raw models. 7 | 8 | 9 | ## Installation 10 | 11 | If you haven't installed traintool yet, now is a good time: 12 | 13 | ```bash 14 | pip install git+https://github.com/jrieke/traintool 15 | ``` 16 | 17 | 18 | ## Dataset 19 | 20 | We will use the MNIST dataset throughout this tutorial. Just in case you never heard of 21 | it: MNIST is a popular dataset for image classification. It contains images of 22 | handwritten digits and the task is to predict which digit is shown on a given image. 23 | Below are some examples. 24 | 25 |  26 | -------------------------------------------------------------------------------- /docs/tutorial/quickstart.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "nbformat": 4, 3 | "nbformat_minor": 0, 4 | "metadata": { 5 | "colab": { 6 | "name": "quickstart.ipynb", 7 | "provenance": [], 8 | "collapsed_sections": [] 9 | }, 10 | "kernelspec": { 11 | "name": "python3", 12 | "display_name": "Python 3" 13 | } 14 | }, 15 | "cells": [ 16 | { 17 | "cell_type": "markdown", 18 | "metadata": { 19 | "id": "ak4L7hONDZdx" 20 | }, 21 | "source": [ 22 | "# Quickstart\n", 23 | "\n", 24 | "Welcome to **traintool**!\n", 25 | "\n", 26 | "In this quickstart, we will train a few models on MNIST. This should give you a rough overview of what traintool can do. \n", 27 | "\n", 28 | "You can follow along interactively in **Google Colab** (a free Jupyter notebook service):\n", 29 | "\n", 30 | "[](https://colab.research.google.com/github/jrieke/traintool/blob/master/docs/tutorial/quickstart.ipynb)\n", 31 | "\n", 32 | "*We highly recommend to use Colab for this tutorial because it gives you free GPU access, which makes training much faster. Important: To enable GPU support, click on \"Runtime\" -> \"Change runtime type\", select \"GPU\" and hit \"Save\".*\n", 33 | "\n", 34 | "---\n" 35 | ] 36 | }, 37 | { 38 | "cell_type": "markdown", 39 | "metadata": { 40 | "id": "ZHmp7C-GEpLH" 41 | }, 42 | "source": [ 43 | "First, let's install traintool:" 44 | ] 45 | }, 46 | { 47 | "cell_type": "code", 48 | "metadata": { 49 | "id": "sBitaippDXMG" 50 | }, 51 | "source": [ 52 | "!pip install -U git+https://github.com/jrieke/traintool" 53 | ], 54 | "execution_count": null, 55 | "outputs": [] 56 | }, 57 | { 58 | "cell_type": "markdown", 59 | "metadata": { 60 | "id": "IJunE3-NEuCW" 61 | }, 62 | "source": [ 63 | "Next, we import traintool and load the mnist dataset (installed with traintool):" 64 | ] 65 | }, 66 | { 67 | "cell_type": "code", 68 | "metadata": { 69 | "id": "1-dX_WnO1j08" 70 | }, 71 | "source": [ 72 | "import traintool\n", 73 | "import mnist" 74 | ], 75 | "execution_count": null, 76 | "outputs": [] 77 | }, 78 | { 79 | "cell_type": "code", 80 | "metadata": { 81 | "id": "IagipCnO1wfi" 82 | }, 83 | "source": [ 84 | "train_images = mnist.train_images()[:, None] # add color dimension\n", 85 | "train_labels = mnist.train_labels()\n", 86 | "test_images = mnist.test_images()[:, None]\n", 87 | "test_labels = mnist.test_labels()\n", 88 | "\n", 89 | "print(\"Images shape:\", train_images.shape)\n", 90 | "print(\"Labels shape:\", train_labels.shape)" 91 | ], 92 | "execution_count": null, 93 | "outputs": [] 94 | }, 95 | { 96 | "cell_type": "markdown", 97 | "metadata": { 98 | "id": "NWfMdByHE5qM" 99 | }, 100 | "source": [ 101 | "As you can see, all data from the `mnist` package comes as numpy arrays. Images have the shape `num samples x color channels x height x width`. Note that traintool can handle numpy arrays like here as well as image files on your machine (see here)." 102 | ] 103 | }, 104 | { 105 | "cell_type": "markdown", 106 | "metadata": { 107 | "id": "BTyAJVPGMOgs" 108 | }, 109 | "source": [ 110 | "## Your first model" 111 | ] 112 | }, 113 | { 114 | "cell_type": "markdown", 115 | "metadata": { 116 | "id": "x6mlF9hTGaEr" 117 | }, 118 | "source": [ 119 | "Let's train our first model! We will use a very simple model, a support vector classifier (called `svc` in traintool). Training it requires only one line of code:\n", 120 | "\n", 121 | "*Note: We use the config parameter `num_samples` here to train only on a subset of the data to make it faster.*" 122 | ] 123 | }, 124 | { 125 | "cell_type": "code", 126 | "metadata": { 127 | "id": "1OZvJ2kT2CVO" 128 | }, 129 | "source": [ 130 | "svc = traintool.train(\"svc\", \n", 131 | " train_data=[train_images, train_labels], \n", 132 | " test_data=[test_images, test_labels], \n", 133 | " config={\"num_samples\": 500})" 134 | ], 135 | "execution_count": null, 136 | "outputs": [] 137 | }, 138 | { 139 | "cell_type": "markdown", 140 | "metadata": { 141 | "id": "rBm1LQJnGnHl" 142 | }, 143 | "source": [ 144 | "That looks very simple – but under the hood, a lot of stuff happened:\n", 145 | "\n", 146 | "1) traintool printed some **general information** about the experiment: Its ID, which model and configuration was used, where the model is saved and how you can load it later. \n", 147 | "\n", 148 | "2) Then, it **preprocessed** the data. It automatically converted all data to the correct format and applied some light preprocessing that makes sense with this model. \n", 149 | "\n", 150 | "3) It created and **trained** the model. Under the hood, traintool uses different frameworks for this step (e.g. scikit-learn or pytorch) but as a user, you don't have to worry about any of this. After training, traintool printed the resulting accuracies (should be 80-85 % here).\n", 151 | "\n", 152 | "4) traintool automatically **saved** the model, console output and tensorboard logs into a time-stamped folder (see below)." 153 | ] 154 | }, 155 | { 156 | "source": [], 157 | "cell_type": "markdown", 158 | "metadata": {} 159 | }, 160 | { 161 | "source": [ 162 | "## Making predictions" 163 | ], 164 | "cell_type": "markdown", 165 | "metadata": {} 166 | }, 167 | { 168 | "cell_type": "markdown", 169 | "metadata": { 170 | "id": "Mt2auldciv1f" 171 | }, 172 | "source": [ 173 | "To make a prediction with this model, simply use its `predict` function:" 174 | ] 175 | }, 176 | { 177 | "cell_type": "code", 178 | "metadata": { 179 | "id": "dQ6woUskinsi" 180 | }, 181 | "source": [ 182 | "svc.predict(test_images[0])" 183 | ], 184 | "execution_count": null, 185 | "outputs": [] 186 | }, 187 | { 188 | "cell_type": "markdown", 189 | "metadata": { 190 | "id": "XVhM_hkLjAUF" 191 | }, 192 | "source": [ 193 | "This gives you a dictionary with the predicted class and probabilities for each class. Note that for now, `predict` can only process a single image at a time. As the `train` method, it works with numpy arrays and image files (see here)." 194 | ] 195 | }, 196 | { 197 | "cell_type": "markdown", 198 | "metadata": { 199 | "id": "zNhKQxCdMQ9G" 200 | }, 201 | "source": [ 202 | "## Using other models" 203 | ] 204 | }, 205 | { 206 | "cell_type": "markdown", 207 | "metadata": { 208 | "id": "BPamL3DbJ72B" 209 | }, 210 | "source": [ 211 | "\n", 212 | "Ok, now what if you want to train a different model? traintool makes this very easy: You only have to call the `train` function with a different model name – no need to rewrite the implementation or change the data just because you use a model from a different framework!\n", 213 | "\n", 214 | "Let's train a residual network (`resnet18`), a deep neural network from pytorch (make sure to use a GPU!):" 215 | ] 216 | }, 217 | { 218 | "cell_type": "code", 219 | "metadata": { 220 | "id": "lskB7rhw2E37" 221 | }, 222 | "source": [ 223 | "resnet = traintool.train(\"resnet18\", \n", 224 | " train_data=[train_images, train_labels],\n", 225 | " test_data=[test_images, test_labels],\n", 226 | " config={\"batch_size\": 128, \"print_every\": 10, \"num_epochs\": 2, \"num_samples\": 10000})" 227 | ], 228 | "execution_count": null, 229 | "outputs": [] 230 | }, 231 | { 232 | "cell_type": "markdown", 233 | "metadata": { 234 | "id": "rYUNQIAEUSu3" 235 | }, 236 | "source": [ 237 | "And with this simple command, you can train all models supported by traintool! See [here](https://traintool.jrieke.com/models/image-classification/) for a list of models. \n", 238 | "\n", 239 | "As you may have noticed, we set some parameters with the `config` argument above. `config` is the central place to define hyperparameters for training. The supported hyperparameters vary from model to model – it's best to have a look at the overview page linked above. \n", 240 | "\n" 241 | ] 242 | }, 243 | { 244 | "cell_type": "markdown", 245 | "metadata": { 246 | "id": "j8Mdq6AXcomF" 247 | }, 248 | "source": [ 249 | "## Experiment tracking" 250 | ] 251 | }, 252 | { 253 | "cell_type": "markdown", 254 | "metadata": { 255 | "id": "BlkMmxlZctbs" 256 | }, 257 | "source": [ 258 | "traintool automatically keeps track of all experiments you run. Each experiment is stored in a time-stamped folder in `./traintool-experiments`. Have a look at this folder now to see the experiments you ran above! (If you are in Colab, click on the folder icon on the top left).\n", 259 | "\n", 260 | "*Tip: You can disable saving with `save=False`.*" 261 | ] 262 | }, 263 | { 264 | "cell_type": "markdown", 265 | "metadata": { 266 | "id": "cyngzaQteHQ0" 267 | }, 268 | "source": [ 269 | "Each experiment folder contains:\n", 270 | "\n", 271 | "- `info.yml`: General information about the experiment\n", 272 | "- `stdout.log`: The entire console output\n", 273 | "- model files and possibly checkpoints (e.g. the pytorch binary `model.pt` for resnet18)\n", 274 | "- tensorboard logs (see below)" 275 | ] 276 | }, 277 | { 278 | "source": [ 279 | "## Visualizations" 280 | ], 281 | "cell_type": "markdown", 282 | "metadata": {} 283 | }, 284 | { 285 | "cell_type": "markdown", 286 | "metadata": { 287 | "id": "tl41Bq9teL-Y" 288 | }, 289 | "source": [ 290 | "traintool writes all metrics and evaluations to [tensorboard](https://www.tensorflow.org/tensorboard), a powerful visualization platform from tensorflow. Let's start tensorboard now: If you are on a local machine, start a terminal in this dir and type `tensorboard --logdir traintool-experiments`. If you are on Colab, just run the cell below:" 291 | ] 292 | }, 293 | { 294 | "cell_type": "code", 295 | "metadata": { 296 | "id": "Wk2eD-9mCeRn" 297 | }, 298 | "source": [ 299 | "%load_ext tensorboard\n", 300 | "%tensorboard --logdir traintool-experiments/" 301 | ], 302 | "execution_count": null, 303 | "outputs": [] 304 | }, 305 | { 306 | "cell_type": "markdown", 307 | "metadata": { 308 | "id": "Ldx4CtPHe5jC" 309 | }, 310 | "source": [ 311 | "Let's see what's going on here: On the bottom left, you can select individual experiments. On the right, you should by default see scalar metrics: The loss and accuracy for train and test set. You can also click on `Images` at the top to see some sample images from both datasets along with classification results (use the sliders to look at different epochs!).\n", 312 | "\n", 313 | "*Tip: You can also store metrics in comet.ml, see here.*" 314 | ] 315 | }, 316 | { 317 | "cell_type": "markdown", 318 | "metadata": { 319 | "id": "1bzWx_7Lh3Zn" 320 | }, 321 | "source": [ 322 | "## Other functions" 323 | ] 324 | }, 325 | { 326 | "cell_type": "markdown", 327 | "metadata": { 328 | "id": "Z66dv-Rnh6-D" 329 | }, 330 | "source": [ 331 | "Before we end this quickstart, let's look at three other important functions:\n", 332 | "\n", 333 | "- **Loading:** To load a saved model, just pass its ID (or directory path) to `traintool.load(...)`. Check out the line starting with `Load via:` in the console output above – it shows you directly which command to call.\n", 334 | "- **Deployment:** traintool can easily deploy your trained model through a REST API. Simply call `model.deploy()` to start the server (note that this call is blocking!). More information here.\n", 335 | "- **Raw models:** traintool models are implemented in different frameworks, e.g. scikit-learn or pytorch. You can get access to the raw models by calling `model.raw()`. " 336 | ] 337 | }, 338 | { 339 | "cell_type": "markdown", 340 | "metadata": { 341 | "id": "abU5z1zVkWRS" 342 | }, 343 | "source": [ 344 | "\n", 345 | "---" 346 | ] 347 | }, 348 | { 349 | "cell_type": "markdown", 350 | "metadata": { 351 | "id": "D8FUSxzjj6pu" 352 | }, 353 | "source": [ 354 | "That's it! You should now be able to start using traintool. Make sure to read the complete tutorial and documentation to learn more! \n", 355 | "\n", 356 | "Please also consider leaving a ⭐ on our [Github](https://github.com/jrieke/traintool)." 357 | ] 358 | } 359 | ] 360 | } -------------------------------------------------------------------------------- /docs/tutorial/raw-models.md: -------------------------------------------------------------------------------- 1 | # Accessing raw models 2 | 3 | traintool is built on top of powerful machine learning libraries like scikit-learn or p 4 | ytorch. After training, it gives you full access to the raw models with: 5 | 6 | ```python 7 | model.raw() 8 | ``` 9 | 10 | This returns a dict of all underlying model objects. It usually contains the model 11 | itself (`model.raw()["model"]`) but might also contain some other 12 | objects, e.g. data scalers (`model.raw()["scaler"]`). 13 | -------------------------------------------------------------------------------- /docs/tutorial/training.md: -------------------------------------------------------------------------------- 1 | # Training and Prediction 2 | 3 | ## Your first model 4 | 5 | As a first example, we'll train a very simple model: A 6 | [Support Vector Machine](https://en.wikipedia.org/wiki/Support_vector_machine) or SVM. 7 | We will use the image classification dataset MNIST throughout this tutorial, so let's 8 | load it now (the `mnist` package was installed along with traintool): 9 | 10 | ```python 11 | import mnist 12 | train_data = [mnist.train_images(), mnist.train_labels()] 13 | test_data = [mnist.test_images(), mnist.test_labels()] 14 | ``` 15 | 16 | !!! tip 17 | The code above loads the data as numpy arrays but traintool can also deal with 18 | files and pytorch datasets (see here). More data formats will be added soon. 19 | 20 | Training the SVM classifier is very simple now: 21 | 22 | ```python 23 | import traintool 24 | svc = traintool.train("svc", train_data=train_data, test_data=test_data) 25 | ``` 26 | 27 | That's it! traintool will take care of reading and converting the data, applying some 28 | light preprocessing, training and saving the model, and tracking all metrics. It will 29 | also print out the final loss and accuracy (the test accuracy should be around XX % 30 | here). 31 | 32 | 33 | ## Making predictions 34 | 35 | Of course, you can do predictions with the trained model. Let's run it on an image of 36 | the test set: 37 | 38 | ```python 39 | pred = svc.predict(test_data[0][0]) 40 | print("Predicted:", pred["predicted_class"], " - Is:", test_data[1][0]) 41 | ``` 42 | 43 | This should print out the predicted class and the ground truth. Note that `pred` is a 44 | dictionary with the predicted class (`pred["predicted_class"]`) and the probabilities 45 | for each class (`pred["probabilities"]`). 46 | 47 | !!! tip 48 | Again, we use a numpy array for the test image here but traintool can also handle 49 | pytorch tensors and files. You can even pass in a whole batch of images 50 | (e.g. `test_data[0][0:2]`). 51 | 52 | 53 | ## Using other models 54 | 55 | Now, let's check a more advanced model. We will train a [Residual Network](https://arxiv.org/abs/1512.03385) 56 | (ResNet), a modern deep neural network. Usually, training this model instead of an SVM 57 | would require you to use an advanced framework like pytorch or tensorflow and rewrite 58 | most of your codebase. With traintool, it's as simple replacing the model name in the `train` method: 59 | 60 | ```python 61 | resnet = traintool.train("resnet", train_data=train_data, test_data=test_data) 62 | ``` 63 | 64 | And this syntax stays the same for every other model that traintool supports! This makes 65 | it really easy to compare a bunch of different models on your dataset and see what 66 | performs best. 67 | 68 | 69 | ## Custom hyperparameters 70 | 71 | In machine learning, most models have some hyperparameters that control the training 72 | process (e.g. the learning rate). traintool uses sensible defaults specific to each 73 | model, but gives you the flexibility to fully customize everything. 74 | 75 | First, let's find out which hyperparameters the model supports and what their defaults 76 | are: 77 | 78 | ```python 79 | print(traintool.default_hyperparameters("resnet")) 80 | ``` 81 | 82 | This should print out a dictionary of hyperparameters and defaults. Now, we want to 83 | change the learning rate and use a different optimizer. To do this, simply pass a 84 | `config` dict to the train method: 85 | 86 | ```python 87 | config = {"lr": 0.1, "optimizer": "adam"} 88 | better_resnet = traintool.train("resnet", config=config, train_data=train_data, test_data=test_data) 89 | ``` 90 | 91 | 92 | ## Saving and loading models 93 | 94 | There are two options to save a model to disk. Either use the `save` method after 95 | training like this: 96 | 97 | ```python 98 | model = traintool.train("...") 99 | model.save("path/to/dir") 100 | ``` 101 | 102 | Or you can specify an output directory directly during training. This makes sense for 103 | long-running processes, so you don't lose the whole progress in case your machine is 104 | interrupted: 105 | 106 | ```python 107 | model = traintool.train("...", save="path/to/dir") 108 | ``` 109 | 110 | In both cases, loading a model works via: 111 | 112 | ```python 113 | model = traintool.load("path/to/dir") 114 | ``` 115 | 116 | 117 |