1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
|
"""
Create and Train Simple MLP for scikit make_moons.
Convert and Save in OpenVino Intermediate Representation (IR)
"""
import openvino as ov
import torch
from torch import nn
import matplotlib.pyplot as plt
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
class SimpleMLP(nn.Module):
def __init__(self):
super(SimpleMLP, self).__init__()
self.layer1 = nn.Linear(2, 4) # Hidden layer
self.layer2 = nn.Linear(4, 1) # Output layer
def forward(self, x):
x = self.layer1(x)
x = torch.sigmoid(x) # Activation function
x = self.layer2(x)
return x
if __name__ == '__main__':
# Generate dataset
X, y = make_moons(n_samples=1000, noise=0.2, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Standardize the data
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
# Plot make_moons
fig,ax1 = plt.subplots(nrows=1,ncols=1,figsize=(8,4))
ax1.scatter(X[:,0],X[:,1],c=y)
plt.show()
# Convert to PyTorch tensors
X_train = torch.tensor(X_train, dtype=torch.float32)
y_train = torch.tensor(y_train, dtype=torch.float32).reshape(-1, 1)
X_test = torch.tensor(X_test, dtype=torch.float32)
y_test = torch.tensor(y_test, dtype=torch.float32).reshape(-1, 1)
model = SimpleMLP()
criterion = nn.MSELoss() # Mean Squared Error for regression
optimizer = torch.optim.SGD(model.parameters(), lr=0.01) # Stochastic Gradient Descent
losses = []
for epoch in range(1000): # Number of epochs
optimizer.zero_grad() # Clear gradients
outputs = model(X_train) # Forward pass
loss = criterion(outputs, y_train) # Compute loss
loss.backward() # Backward pass
losses.append(loss.item())
optimizer.step() # Update parameters
plt.plot(losses)
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.title("Training Loss over Epochs")
plt.show()
with torch.no_grad():
raw_output = model.forward(X_test)
test_output = (raw_output > 0.5).float()
accuracy = torch.mean((test_output == y_test).float())
print(f"Test Accuracy: {accuracy.item() * 100:.2f}%")
# Convert and Save to OpenVino Intermediate Representation (IR)
ov_input=(ov.PartialShape([1, 2]), ov.Type.f32)
ov_model = ov.convert_model(model, input=ov_input)
compiled_model = ov.compile_model(ov_model, "AUTO")
ov.save_model(ov_model,'./mlp.xml')
print("finished")
|
