Inteligentny System Ostrzegania Klientów

class FTTransformer(nn.Module):
    def __init__(self, n_num, n_cat, dim=192, depth=6, heads=8):
        self.num_tok = NumericalTokenizer(n_num, dim)
        self.cat_tok = CategoricalTokenizer(n_cat, dim)
        self.cls     = nn.Parameter(torch.zeros(1, 1, dim))
        self.blocks  = nn.ModuleList([
            TransformerBlock(dim, heads) for _ in range(depth)
        ])

    def forward(self, x_num, x_cat):
        tokens = torch.cat([
            self.cls.expand(x_num.size(0), -1, -1),
            self.num_tok(x_num),
            self.cat_tok(x_cat),
        ], dim=1)
        for blk in self.blocks:
            tokens = blk(tokens)
        # CLS-token → embedding klienta
        return tokens[:, 0]

import umap

reducer = umap.UMAP(
    n_neighbors=30,         # balans lokalne ↔ globalne
    min_dist=0.05,          # gęstość klastrów docelowych
    n_components=8,         # docelowy wymiar k
    metric='euclidean',
    random_state=42,        # deterministyczne wyniki
)
embedding_low = reducer.fit_transform(embedding_high)

import hdbscan

clusterer = hdbscan.HDBSCAN(
    min_cluster_size=200,           # min. liczność grupy ryzyka
    min_samples=15,                 # tolerancja na szum
    cluster_selection_method='eom',   # stabilne klastry o różnej gęstości
    metric='euclidean',
    prediction_data=True,            # soft-clustering nowych klientów
)
labels = clusterer.fit_predict(embedding_low)
# labels == -1  →  outlier (niesklasyfikowany)

class TransformerHawkesProcess(nn.Module):
    def __init__(self, n_types, d_model=64, n_heads=4, n_layers=4):
        self.type_emb  = nn.Embedding(n_types, d_model)
        self.time_enc  = TemporalEncoding(d_model)
        self.encoder   = TransformerEncoder(d_model, n_heads, n_layers)
        self.intensity = nn.Linear(d_model, n_types)

    def forward(self, event_types, event_times):
        h = self.type_emb(event_types) + self.time_enc(event_times)
        h = self.encoder(h, mask=causal_mask(len(h)))
        # λ_k(t) = softplus(W·h_t)  →  sygnatura σ̂
        return F.softplus(self.intensity(h))