재교육시기와 언제 낙상을하지 않습니까?

import numpy as np

import matplotlib.pyplot as plt

from sklearn.model_selection import train_test_split

from sklearn.linear_model import LogisticRegression

from sklearn.preprocessing import StandardScaler

# Original Dataset 

X = np.array([[1, 2], [2, 3], [4, 5], [6, 7], [8, 9]])

y = np.array([0, 0, 1, 1, 1])

# split train test 

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.5, stratify=y, random_state=42)

# feature scaling

scaler = StandardScaler()

X_train_scaled = scaler.fit_transform(X_train)

X_test_scaled = scaler.transform(X_test)

# Before Retraining

model_before = LogisticRegression(solver="lbfgs", max_iter=200, class_weight="balanced")

model_before.fit(X_train_scaled, y_train)

# Ensuring atleast one sample for both

X_train_reduced = []

y_train_reduced = []

# Track the number of samples per class

class_counts = {0: 0, 1: 0} 

for i in range(len(y_train)):

    if class_counts[y_train[i]] 

Initial Model Accuracy: 0.67 
Model Accuracy After Retraining: 0.67

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt

# helper function get
def get_flat_params(model):
    """Flatten all the model parameters into a single vector"""
    parameters = []
    for parameter in model.parameters():
        parameters.append(parameter.view(-1))
    return torch.cat(parameters)

# helper function for set
def set_flat_params(model, flat_params):
    """Set model parameters from a flattened vector"""
    offset = 0
    for parameter in model.parameters():
        numel = parameter.numel()
        parameter.data.copy_(flat_params[offset:offset+numel].view(parameter.size()))
        offset += numel

# LR Model
class LogisticRegressionModel(nn.Module):
    def __init__(self, input_dim):
        super().__init__()
        self.linear = nn.Linear(input_dim, 1)
    
    def forward(self, x):
        return torch.sigmoid(self.linear(x))

# Datasets
X_np = np.array([[1, 2],[2, 3],[3, 4],[4, 5],[5, 6],[6, 7],[7, 8]], dtype=np.float32)
y_np = np.array([0, 1, 0, 1, 0, 1, 0], dtype=np.float32).reshape(-1, 1)

X = torch.tensor(X_np)
y = torch.tensor(y_np)

# Initialization and Training
model = LogisticRegressionModel(input_dim=2)
criterion = nn.BCELoss()
optimizer = optim.SGD(model.parameters(), lr=0.1)
num_epochs = 1000
for epoch in range(num_epochs):
    optimizer.zero_grad()
    outputs = model(X)
    loss = criterion(outputs, y)
    loss.backward()
    optimizer.step()

# Before unlearning
with torch.no_grad():
    preds = (model(X) > 0.5).float()
    accuracy_before = (preds == y).float().mean().item()
    print("Accuracy before unlearning: {:.2f}".format(accuracy_before))

# Hessian and Its Inverse
loss_full = criterion(model(X), y)
grad_params = torch.autograd.grad(loss_full, model.parameters(), create_graph=True)
grad_flat = torch.cat([g.view(-1) for g in grad_params])
n_params = grad_flat.numel()
Hessian = torch.zeros((n_params, n_params))
for i in range(n_params):
    grad2 = torch.autograd.grad(grad_flat[i], model.parameters(), retain_graph=True)
    grad2_flat = torch.cat([g.contiguous().view(-1) for g in grad2])
    Hessian[i] = grad2_flat
Hessian_inv = torch.inverse(Hessian)

# Influence for a Specific Data Point
index_to_remove = 2  # Data point [3, 4] with label 0
x_remove = X[index_to_remove:index_to_remove+1]
y_remove = y[index_to_remove:index_to_remove+1]
loss_remove = criterion(model(x_remove), y_remove)
grad_remove = torch.autograd.grad(loss_remove, model.parameters())
grad_remove_flat = torch.cat([g.view(-1) for g in grad_remove])
n = X.size(0)
delta_theta = - (1.0/n) * torch.matmul(Hessian_inv, grad_remove_flat)

# Update the Model Parameters
flat_params_new = get_flat_params(model) + delta_theta
set_flat_params(model, flat_params_new)

# Evaluate after unlearning
with torch.no_grad():
    preds_after = (model(X) > 0.5).float()
    accuracy_after = (preds_after == y).float().mean().item()
    print("Accuracy after unlearning: {:.2f}".format(accuracy_after))