# Python to R

## Loading models saved in python

Currently the only way to load models from python is to rewrite the model architecture in R. All the parameter names must be identical. A complete example from Python to R is shown below. This is an extension of the Serialization vignette.

An artificial neural net is implemented below in Python. Note the final line which uses torch.save().

```{python eval=FALSE] import torch import numpy as np

#Make up data

madeUpData_x = np.random.rand(1000,100) madeUpData_y = np.random.rand(1000)

#Convert to categorical madeUpData_y = madeUpData_y.round()

train_py_X = torch.from_numpy(madeUpData_x).float()

train_py_Y = torch.from_numpy(madeUpData_y).float()

#Note that this class must be replicated identically in R class simpleMLP(torch.nn.Module): def init(self): super(simpleMLP, self).__init__() self.modelFit = torch.nn.Sequential( torch.nn.Linear(100,20), torch.nn.ReLU(), torch.nn.Linear(20,1), torch.nn.Sigmoid())

    def forward(self, x):
        x =self.modelFit(x)

        return x

model = simpleMLP()

def modelTrainer(data_X,data_Y,model): criterion = torch.nn.BCELoss() optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)

    for epoch in range(100):

        optimizer.zero_grad()

        yhat = model(data_X)

        loss = criterion(yhat,data_Y.unsqueeze(1))

        loss.backward()
        optimizer.step()

modelTrainer(data_X = train_py_X,data_Y = train_py_Y,model = model)

#—————————————————————– #save the model

#Note that model.state_dict() comes out as an ordered dictionary #The code below converts to a dictionary stateDict = dict(model.state_dict())

#Note the argument _use_new_zipfile_serialization torch.save(stateDict,f=“path/babyTest.pth”, _use_new_zipfile_serialization=True)

    Once we have a saved .pth object we can load this into R. An example use case
    would be training a model in Python then using Shiny to develop a GUI for predictions
    from a trained model.

    ```r
    library(torch)

    #Make up some test data
    #note that proper installation of torch will yield no errors when we run
    #this code
    y <- torch_tensor(array(runif(8),dim = c(2,2,2)),dtype = torch_float64())

    #Note the identical names between the Python class definition and our
    #class definition
    simpleMLP <- torch::nn_module(
      "simpleMLP",
      initialize = function(){

        self$modelFit <- nn_sequential(nn_linear(100,20),
                                       nn_relu(),
                                       nn_linear(20,1),
                                       nn_sigmoid())

      },
      forward = function(x){
        self$modelFit(x)
        }
    )

    model <- simpleMLP()

    state_dict <- torch::load_state_dict("p/babyTest.pth")
    model$load_state_dict(state_dict)

    #Note that the dtype set in R has to match the made up data from Python
    #More generally if reading new data into R you must ensure that it matches the
    #dtype that the model was trained with in Python
    newData = torch_tensor(array(rnorm(n=1000),dim=c(10,100)),dtype=torch_float32())

    predictMe <- model(newData)