PyTorch

import torch
import sol
import torchvision.models as models

''' Training in PyTorch requires to use a loss function at the end of the network
that is normal not part of the structure. To add the loss function into the SOL
model you can embed it into a wrapper model like this.'''

class TrainingModel(torch.nn.Module):
	def __init__(self, model):
		super().__init__()
		self.m_model = model
		self.m_loss  = torch.nn.L1Loss()
		
	def forward(self, x, y, z, target):
		output = self.m_model(x, y, z)
		loss = self.m_loss(A, target)
		return sol.no_grad(output), loss

py_model = models.__dict__["alexnet"]()
input	= torch.rand(32, 3, 224, 224)
target	= torch.rand(32, 1000)

opt = sol.optimize(TrainingModel(py_model), input, target)

''' Run training '''
opt.train()
for batch in ...:
	input, target = ...
	output, loss = opt(input, target)
	loss.backward()
	...

''' Run validation '''
opt.eval()
with torch.no_grad():
	for batch in ...:
		input, target = ...
		output = opt(input, target)[0]
		...
		
''' Deploying model needs to be called on the PyTorch model. Direct deployment of SOL models is not supported yet. '''
py.load_state_dict(opt.state_dict(), strict=False)
sol.deploy(py, sol.input([1, 3, 224, 224]), libName="libmynetwork", funcName="predict", deployPath=".", sol.deployment.SharedLib, sol.device.x86)

from torchvision import models

class Wrap(torch.nn.Module):
	def __init__(self, model):
		super().__init__()
		self.model = model

	def forward(self, x):
		out = self.model(x)
		if torch.jit.is_scripting():
			return (out[0], out[1]) if self.training else (out[0], None)
		return (out[0], out[1]) if self.training else (out, None)

model = Wrap(models.inception_v3())

# use only one output
model.training = False
sol_model = sol.optimize(model, ...)

# use two outputs
model.training = True
sol_model = sol.optimize(model, ...)