# 加载数据
iris = load_iris()
X, y = iris.data, iris.target

# 训练模型
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X, y)

# 使用pickle序列化
with open(‘model.pkl’, ‘wb’) as f:
pickle.dump(model, f)

# 使用joblib序列化
joblib.dump(model, ‘model.joblib’)

# 加载序列化的模型
with open(‘model.pkl’, ‘rb’) as f:
loaded_model = pickle.load(f)

# 验证模型
print(loaded_model.predict([[5.1, 3.5, 1.4, 0.2]]))
# 输出: [0]

# 创建模型
model = Sequential([
Dense(64, activation=’relu’, input_shape=(4,)),
Dense(3, activation=’softmax’)
])

# 编译模型
model.compile(optimizer=’adam’,
loss=’sparse_categorical_crossentropy’,
metrics=[‘accuracy’])

# 训练模型（使用iris数据）
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

iris = load_iris()
X, y = iris.data, iris.target
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42)

model.fit(X_train, y_train, epochs=50, batch_size=32, verbose=0)

# 保存为SavedModel格式
model.save(‘tf_model’)

# 加载模型
loaded_model = tf.keras.models.load_model(‘tf_model’)

# 验证模型
print(loaded_model.predict([[5.1, 3.5, 1.4, 0.2]]))
# 输出: [[0.99999994 6.1035156e-08 0.0]]

# 准备数据
iris = load_iris()
X, y = iris.data, iris.target
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42)

# 转换为张量
X_train = torch.tensor(X_train, dtype=torch.float32)
y_train = torch.tensor(y_train, dtype=torch.long)
X_test = torch.tensor(X_test, dtype=torch.float32)
y_test = torch.tensor(y_test, dtype=torch.long)

# 创建模型
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.fc1 = nn.Linear(4, 64)
self.fc2 = nn.Linear(64, 3)

def forward(self, x):
x = torch.relu(self.fc1(x))
x = self.fc2(x)
return x

model = Net()

# 训练模型
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

for epoch in range(50):
optimizer.zero_grad()
outputs = model(X_train)
loss = criterion(outputs, y_train)
loss.backward()
optimizer.step()

# 保存模型（仅保存参数）
torch.save(model.state_dict(), ‘pytorch_model.pth’)

# 保存整个模型
torch.save(model, ‘pytorch_model_full.pth’)

# 加载模型
loaded_model = Net()
loaded_model.load_state_dict(torch.load(‘pytorch_model.pth’))
loaded_model.eval()

# 验证模型
with torch.no_grad():
output = loaded_model(torch.tensor([[5.1, 3.5, 1.4, 0.2]], dtype=torch.float32))
print(torch.argmax(output, dim=1).item())
# 输出: 0

# 导出为ONNX格式（以PyTorch为例）
import torch
import torch.nn as nn
import onnx

# 创建模型
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.fc1 = nn.Linear(4, 64)
self.fc2 = nn.Linear(64, 3)

def forward(self, x):
x = torch.relu(self.fc1(x))
x = self.fc2(x)
return x

model = Net()

# 导出为ONNX格式
dummy_input = torch.randn(1, 4)
torch.onnx.export(model, dummy_input, ‘model.onnx’,
input_names=[‘input’],
output_names=[‘output’],
dynamic_axes={‘input’: {0: ‘batch_size’},
‘output’: {0: ‘batch_size’}})

# 验证ONNX模型
onnx_model = onnx.load(‘model.onnx’)
onnx.checker.check_model(onnx_model)
print(‘ONNX模型验证成功’)

# 使用ONNX Runtime推理
import onnxruntime as rt
sess = rt.InferenceSession(‘model.onnx’)
input_name = sess.get_inputs()[0].name
output_name = sess.get_outputs()[0].name

input_data = [[5.1, 3.5, 1.4, 0.2]]
result = sess.run([output_name], {input_name: input_data})
print(result)
# 输出: [array([[…]], dtype=float32)]