# Train-Pytorch
Simlified pytorch training!
PyPI project: https://pypi.org/project/train-pytorch/
The package provide:
- A basic `Trainer` class to facilidate pytorch model training.
- Some functions to compute common accuracy metrics including:
- `binary_accuracy`
- `multiple_class_accuracy`
- `regression_r2`
You can also define your own function to input into the `Trainer` class as long as your function can:
- take 2 inputs: `logits` and `labels`
- perform all computation on: `torch.tensor`
- return a python value by: `value.item()`
An example of our provided `binary_accuracy` function is:
```python
def binary_accuracy(logits, labels, cutoff=0):
"""
Compute binary classification accuracy score.
return accuracy value
Args:
logits: logits - outputs of the model
labels: true labels of data
cutoff: default is 0 - model outputs logits
can be set to 1 - if model outputs probabilities
"""
logits, labels = logits.cpu(), labels.cpu()
predicts = (logits > cutoff).float()
acc = (predicts == labels).float().mean()
return acc.item()
```
## 1. Installation
From Github:
```console
git clone https://github.com/datngu/train_pytorch
cd train_pytorch
pip install .
```
From PyPI:
```console
pip install train-pytorch
```
## 1. Example on the MNIST dataset with multiple_class_accuracy
### 1.1 Load your libraries
```python
import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
## import train_pytorch packages and metric functions
from train_pytorch import Trainer, binary_accuracy, multiple_class_accuracy, regression_r2
```
### 1.2 Load your dataset
```python
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5,), (0.5,))
])
train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)
test_dataset = datasets.MNIST(root='./data', train=False, transform=transform, download=True)
train_loader = DataLoader(train_dataset, batch_size=512, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=512, shuffle=False)
```
### 1.3 Buid your model
```python
class CNNModel(nn.Module):
def __init__(self):
super(CNNModel, self).__init__()
self.conv1 = nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1)
self.conv2 = nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1)
self.pool = nn.MaxPool2d(kernel_size=2, stride=2, padding=0)
self.fc1 = nn.Linear(64 * 7 * 7, 128)
self.fc2 = nn.Linear(128, 10)
def forward(self, x):
x = self.pool(torch.relu(self.conv1(x)))
x = self.pool(torch.relu(self.conv2(x)))
x = x.view(-1, 64 * 7 * 7)
x = torch.relu(self.fc1(x))
x = self.fc2(x)
return x
```
### 1.4 Let's train it!
```python
model = CNNModel()
## GPU: optional
#device = torch.device("cuda:0" if torch.cuda.is_available() else "mps")
#model.to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
trainer = Trainer(model, criterion, optimizer, multiple_class_accuracy, num_epochs = 10, early_stoper = 5)
trainer.fit(train_loader, train_loader, './output_dir')
```
## 2. Example on the sklearn breast_cancer dataset with binary_accuracy
### 2.1 Load your libraries
```python
import torch
from torch import nn
from torch.nn import functional as F
import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_breast_cancer
from torch.utils.data import Dataset, DataLoader
## import train_pytorch packages and metric functions
from train_pytorch import Trainer, binary_accuracy, multiple_class_accuracy, regression_r2
```
### 2.2 Load your dataset
```python
data = load_breast_cancer()
x = data['data']
y = data['target']
sc = StandardScaler()
x = sc.fit_transform(x)
## create dataset class
class dataset(Dataset):
def __init__(self,x,y):
self.x = torch.tensor(x,dtype=torch.float32)
self.y = torch.tensor(y,dtype=torch.float32)
self.length = self.x.shape[0]
def __getitem__(self,idx):
return self.x[idx],self.y[idx]
def __len__(self):
return self.length
# a bit lazy to slipt train and test data, but it is okey for tutorial :D
train_data = dataset(x,y)
val_data = dataset(x,y)
train_loader = DataLoader(train_data,batch_size=64,shuffle=False)
val_loader = DataLoader(val_data,batch_size=64,shuffle=False)
```
### 2.3 Buid your model
```python
class Net(nn.Module):
def __init__(self,input_shape):
super(Net,self).__init__()
self.fc1 = nn.Linear(input_shape,32)
self.fc2 = nn.Linear(32,64)
self.fc3 = nn.Linear(64,1)
def forward(self,x):
x = torch.relu(self.fc1(x))
x = torch.relu(self.fc2(x))
x = self.fc3(x)
return x
```
### 2.4 Let's train it!
```python
model = Net(input_shape=x.shape[1])
## GPU: optional
#device = torch.device("cuda:0" if torch.cuda.is_available() else "mps")
#model.to(device)
optimizer = torch.optim.SGD(model.parameters(),lr=0.1)
loss_fn = nn.BCEWithLogitsLoss()
trainer = Trainer(model, loss_fn, optimizer, binary_accuracy, num_epochs=10)
trainer.fit(train_loader, val_loader, './output_dir')
```
Raw data
{
"_id": null,
"home_page": "https://github.com/datngu/train_pytorch",
"name": "train-pytorch",
"maintainer": "",
"docs_url": null,
"requires_python": "",
"maintainer_email": "",
"keywords": "artificial intelligence,deep learning,pytorch",
"author": "Dat T Nguyen",
"author_email": "ndat@utexas.edu",
"download_url": "https://files.pythonhosted.org/packages/26/5b/9439d0ef8f1f53e8b2dfd0dd127a44b9198a56d4076be67f1b6a8bcd117e/train_pytorch-0.0.3.tar.gz",
"platform": null,
"description": "# Train-Pytorch\n\nSimlified pytorch training!\n\nPyPI project: https://pypi.org/project/train-pytorch/\n\nThe package provide:\n- A basic `Trainer` class to facilidate pytorch model training.\n- Some functions to compute common accuracy metrics including:\n - `binary_accuracy`\n - `multiple_class_accuracy`\n - `regression_r2`\n\n\nYou can also define your own function to input into the `Trainer` class as long as your function can:\n- take 2 inputs: `logits` and `labels`\n- perform all computation on: `torch.tensor` \n- return a python value by: `value.item()`\n\nAn example of our provided `binary_accuracy` function is:\n\n```python\n\ndef binary_accuracy(logits, labels, cutoff=0):\n \"\"\"\n Compute binary classification accuracy score.\n return accuracy value\n\n Args:\n logits: logits - outputs of the model\n labels: true labels of data\n cutoff: default is 0 - model outputs logits\n can be set to 1 - if model outputs probabilities\n \"\"\"\n logits, labels = logits.cpu(), labels.cpu()\n predicts = (logits > cutoff).float()\n acc = (predicts == labels).float().mean()\n return acc.item()\n\n```\n\n\n\n\n\n## 1. Installation\n\nFrom Github:\n\n```console\ngit clone https://github.com/datngu/train_pytorch\ncd train_pytorch\npip install .\n```\n\nFrom PyPI:\n\n```console\npip install train-pytorch\n```\n\n\n## 1. Example on the MNIST dataset with multiple_class_accuracy\n\n### 1.1 Load your libraries\n```python\n\nimport torch\nimport torch.nn as nn\nimport torch.optim as optim\nfrom torchvision import datasets, transforms\nfrom torch.utils.data import DataLoader\n\n## import train_pytorch packages and metric functions\nfrom train_pytorch import Trainer, binary_accuracy, multiple_class_accuracy, regression_r2\n\n```\n\n### 1.2 Load your dataset\n\n```python\n\ntransform = transforms.Compose([\n transforms.ToTensor(),\n transforms.Normalize((0.5,), (0.5,))\n])\n\ntrain_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)\ntest_dataset = datasets.MNIST(root='./data', train=False, transform=transform, download=True)\n\ntrain_loader = DataLoader(train_dataset, batch_size=512, shuffle=True)\ntest_loader = DataLoader(test_dataset, batch_size=512, shuffle=False)\n\n```\n\n### 1.3 Buid your model\n\n```python\n\nclass CNNModel(nn.Module):\n def __init__(self):\n super(CNNModel, self).__init__()\n self.conv1 = nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1)\n self.conv2 = nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1)\n self.pool = nn.MaxPool2d(kernel_size=2, stride=2, padding=0)\n self.fc1 = nn.Linear(64 * 7 * 7, 128)\n self.fc2 = nn.Linear(128, 10)\n\n def forward(self, x):\n x = self.pool(torch.relu(self.conv1(x)))\n x = self.pool(torch.relu(self.conv2(x)))\n x = x.view(-1, 64 * 7 * 7)\n x = torch.relu(self.fc1(x))\n x = self.fc2(x)\n return x\n\n\n```\n\n\n### 1.4 Let's train it!\n\n```python\n\nmodel = CNNModel()\n\n## GPU: optional\n#device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"mps\")\n#model.to(device)\n\ncriterion = nn.CrossEntropyLoss()\noptimizer = optim.Adam(model.parameters(), lr=0.001)\n\n\ntrainer = Trainer(model, criterion, optimizer, multiple_class_accuracy, num_epochs = 10, early_stoper = 5)\n\ntrainer.fit(train_loader, train_loader, './output_dir')\n\n```\n\n\n## 2. Example on the sklearn breast_cancer dataset with binary_accuracy\n\n### 2.1 Load your libraries\n```python\n\nimport torch\nfrom torch import nn\nfrom torch.nn import functional as F\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom sklearn.preprocessing import StandardScaler\nfrom sklearn.datasets import load_breast_cancer\nfrom torch.utils.data import Dataset, DataLoader\n\n## import train_pytorch packages and metric functions\nfrom train_pytorch import Trainer, binary_accuracy, multiple_class_accuracy, regression_r2\n\n```\n\n\n### 2.2 Load your dataset\n\n```python\n\ndata = load_breast_cancer()\nx = data['data']\ny = data['target']\n\nsc = StandardScaler()\nx = sc.fit_transform(x)\n\n## create dataset class\nclass dataset(Dataset):\n def __init__(self,x,y):\n self.x = torch.tensor(x,dtype=torch.float32)\n self.y = torch.tensor(y,dtype=torch.float32)\n self.length = self.x.shape[0]\n \n def __getitem__(self,idx):\n return self.x[idx],self.y[idx]\n def __len__(self):\n return self.length\n \n# a bit lazy to slipt train and test data, but it is okey for tutorial :D \ntrain_data = dataset(x,y)\nval_data = dataset(x,y)\n\ntrain_loader = DataLoader(train_data,batch_size=64,shuffle=False)\nval_loader = DataLoader(val_data,batch_size=64,shuffle=False)\n\n\n```\n\n\n### 2.3 Buid your model\n\n```python\n\nclass Net(nn.Module):\n def __init__(self,input_shape):\n super(Net,self).__init__()\n self.fc1 = nn.Linear(input_shape,32)\n self.fc2 = nn.Linear(32,64)\n self.fc3 = nn.Linear(64,1)\n def forward(self,x):\n x = torch.relu(self.fc1(x))\n x = torch.relu(self.fc2(x))\n x = self.fc3(x)\n return x\n\n\n```\n\n\n### 2.4 Let's train it!\n\n```python\n\nmodel = Net(input_shape=x.shape[1])\n\n## GPU: optional\n#device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"mps\")\n#model.to(device)\n\noptimizer = torch.optim.SGD(model.parameters(),lr=0.1)\nloss_fn = nn.BCEWithLogitsLoss()\n\n\ntrainer = Trainer(model, loss_fn, optimizer, binary_accuracy, num_epochs=10)\ntrainer.fit(train_loader, val_loader, './output_dir')\n\n```\n",
"bugtrack_url": null,
"license": "MIT",
"summary": "Simple trainer for pytorch.",
"version": "0.0.3",
"project_urls": {
"Homepage": "https://github.com/datngu/train_pytorch"
},
"split_keywords": [
"artificial intelligence",
"deep learning",
"pytorch"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "159b9e08d6622e1b12aaf73a20f9d18434b066bae3d1b3b8949c16b9900bdcab",
"md5": "0f70f4ed3f145d3f15a3e0c303f4dec2",
"sha256": "674bc0fae1dc4ebc0556c9aa72796083c7ecc2baf8e05420a0ef6dbdc5dd4851"
},
"downloads": -1,
"filename": "train_pytorch-0.0.3-py3-none-any.whl",
"has_sig": false,
"md5_digest": "0f70f4ed3f145d3f15a3e0c303f4dec2",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": null,
"size": 6760,
"upload_time": "2024-01-05T09:33:42",
"upload_time_iso_8601": "2024-01-05T09:33:42.555053Z",
"url": "https://files.pythonhosted.org/packages/15/9b/9e08d6622e1b12aaf73a20f9d18434b066bae3d1b3b8949c16b9900bdcab/train_pytorch-0.0.3-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "265b9439d0ef8f1f53e8b2dfd0dd127a44b9198a56d4076be67f1b6a8bcd117e",
"md5": "397d57768bd910239571c11960c3931b",
"sha256": "8823a225214e214ec3ca6dffc19c92af325fc03d71e955ba217d2441da0a0383"
},
"downloads": -1,
"filename": "train_pytorch-0.0.3.tar.gz",
"has_sig": false,
"md5_digest": "397d57768bd910239571c11960c3931b",
"packagetype": "sdist",
"python_version": "source",
"requires_python": null,
"size": 6393,
"upload_time": "2024-01-05T09:33:43",
"upload_time_iso_8601": "2024-01-05T09:33:43.614990Z",
"url": "https://files.pythonhosted.org/packages/26/5b/9439d0ef8f1f53e8b2dfd0dd127a44b9198a56d4076be67f1b6a8bcd117e/train_pytorch-0.0.3.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2024-01-05 09:33:43",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "datngu",
"github_project": "train_pytorch",
"travis_ci": false,
"coveralls": false,
"github_actions": false,
"lcname": "train-pytorch"
}
JSON
