Docs
...
Creating the initial model

Creación del modelo inicial

Última actualización: 07 oct 2024
Creación del modelo inicial

Las partes pueden crear y guardar el modelo inicial antes del entrenamiento siguiendo un conjunto de ejemplos.

Considere los ejemplos de configuración que coinciden con el tipo de modelo.

Guardar el modelo Tensorflow

import tensorflow as tf
from tensorflow.keras import *
from tensorflow.keras.layers import *
import numpy as np
import os

class MyModel(Model):
    def __init__(self):
        super(MyModel, self).__init__()
        self.conv1 = Conv2D(32, 3, activation='relu')
        self.flatten = Flatten()
        self.d1 = Dense(128, activation='relu')
        self.d2 = Dense(10)

    def call(self, x):
        x = self.conv1(x)
        x = self.flatten(x)
        x = self.d1(x)
        return self.d2(x)

# Create an instance of the model

model = MyModel()
loss_object = tf.keras.losses.SparseCategoricalCrossentropy(
    from_logits=True)
optimizer = tf.keras.optimizers.Adam()
acc = tf.keras.metrics.SparseCategoricalAccuracy(name='accuracy')
model.compile(optimizer=optimizer, loss=loss_object, metrics=[acc])
img_rows, img_cols = 28, 28
input_shape = (None, img_rows, img_cols, 1)
model.compute_output_shape(input_shape=input_shape)

dir = "./model_architecture"
if not os.path.exists(dir):
    os.makedirs(dir)

model.save(dir)

Si elige Tensorflow como infraestructura de modelo, debe guardar un modelo Keras como formato SavedModel . Un modelo Keras se puede guardar en formato SavedModel utilizando tf.keras.model.save().

Para comprimir los archivos, ejecute el mandato zip -r mymodel.zip model_architecture. El contenido del archivo .zip debe contener:

mymodel.zip
└── model_architecture
    ├── assets
    ├── keras_metadata.pb
    ├── saved_model.pb
    └── variables
        ├── variables.data-00000-of-00001
        └── variables.index

Guardar el modelo Scikit-learn

Clasificación SKLearn

# SKLearn classification

from sklearn.linear_model import SGDClassifier
import numpy as np
import joblib

model = SGDClassifier(loss='log', penalty='l2')
model.classes_ = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
# You must specify the class label for IBM Federated Learning using model.classes. Class labels must be contained in a numpy array.
# In the example, there are 10 classes.

joblib.dump(model, "./model_architecture.pickle")

Regresión SKLearn

# Sklearn regression

from sklearn.linear_model import SGDRegressor
import pickle


model = SGDRegressor(loss='huber', penalty='l2')

with open("./model_architecture.pickle", 'wb') as f:
    pickle.dump(model, f)

K-medias SKLearn

# SKLearn Kmeans
from sklearn.cluster import KMeans
import joblib

model = KMeans()
joblib.dump(model, "./model_architecture.pickle")

Debe crear un archivo .zip que contenga el modelo en formato pickle ejecutando el mandato zip mymodel.zip model_architecture.pickle. El contenido del archivo .zip debe contener:

mymodel.zip
└── model_architecture.pickle

Guardar el modelo PyTorch

import torch
import torch.nn as nn

model = nn.Sequential(
    nn.Flatten(start_dim=1, end_dim=-1),
    nn.Linear(in_features=784, out_features=256, bias=True),
    nn.ReLU(),
    nn.Linear(in_features=256, out_features=256, bias=True),
    nn.ReLU(),
    nn.Linear(in_features=256, out_features=256, bias=True),
    nn.ReLU(),
    nn.Linear(in_features=256, out_features=100, bias=True),
    nn.ReLU(),
    nn.Linear(in_features=100, out_features=50, bias=True),
    nn.ReLU(),
    nn.Linear(in_features=50, out_features=10, bias=True),
    nn.LogSoftmax(dim=1),
).double()

torch.save(model, "./model_architecture.pt")

Debe crear un archivo .zip que contenga el modelo en formato de selector. Ejecute el mandato zip mymodel.zip model_architecture.pt. El contenido del archivo .zip debe contener:

mymodel.zip
└── model_architecture.pt

Tema padre: Creación de un experimento de aprendizaje federado