Neyron tarmoqlar asoslari

import numpy as np

def neyron(kirishlar, vaznlar, siljish):
    yigindi = np.dot(kirishlar, vaznlar) + siljish
    return 1 / (1 + np.exp(-yigindi))     # sigmoid


kirishlar = np.array([0.5, 0.3, 0.8])
vaznlar   = np.array([0.4, -0.2, 0.7])
siljish   = 0.1

print(f"Chiqish: {neyron(kirishlar, vaznlar, siljish):.4f}")

from sklearn.linear_model import LogisticRegression

X_xor = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y_xor = np.array([0, 1, 1, 0])

model = LogisticRegression().fit(X_xor, y_xor)
print(f"Chiziqli model aniqligi: {model.score(X_xor, y_xor):.2f}")

from sklearn.neural_network import MLPClassifier

tarmoq = MLPClassifier(
    hidden_layer_sizes=(4,),
    activation="relu",
    max_iter=5000,
    random_state=42,
)
tarmoq.fit(X_xor, y_xor)
print(f"Neyron tarmoq aniqligi: {tarmoq.score(X_xor, y_xor):.2f}")

from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline
from sklearn.neural_network import MLPClassifier

raqamlar = load_digits()
X, y = raqamlar.data, raqamlar.target

print(f"Namunalar: {X.shape[0]}, belgilar: {X.shape[1]}")
print(f"Sinflar: {np.unique(y)}")

X_o, X_s, y_o, y_s = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

tarmoq = make_pipeline(
    StandardScaler(),
    MLPClassifier(
        hidden_layer_sizes=(128, 64),
        activation="relu",
        solver="adam",
        alpha=0.001,
        learning_rate_init=0.001,
        max_iter=500,
        early_stopping=True,
        validation_fraction=0.1,
        n_iter_no_change=15,
        random_state=42,
    ),
)
tarmoq.fit(X_o, y_o)

print(f"O'qitish: {tarmoq.score(X_o, y_o):.3f}")
print(f"Sinov:    {tarmoq.score(X_s, y_s):.3f}")

import matplotlib.pyplot as plt

model = tarmoq.named_steps["mlpclassifier"]

plt.figure(figsize=(9, 5))
plt.plot(model.loss_curve_, label="O'qitish xatosi")
if hasattr(model, "validation_scores_"):
    plt.plot(model.validation_scores_, label="Validatsiya aniqligi")
plt.xlabel("Epoxa")
plt.legend()
plt.grid(alpha=0.3)
plt.show()

print(f"Epoxalar: {model.n_iter_}")
print(f"Yakuniy xato: {model.loss_:.5f}")

from sklearn.neural_network import MLPRegressor

model = make_pipeline(
    StandardScaler(),
    MLPRegressor(
        hidden_layer_sizes=(64, 32),
        max_iter=1000,
        early_stopping=True,
        random_state=42,
    ),
)

# Konvergentsiya ogohlantirishi
tarmoq = MLPClassifier(max_iter=100)
tarmoq.fit(X_o, y_o)

pip install torch
# yoki
pip install tensorflow

import torch
import torch.nn as nn

class Tarmoq(nn.Module):
    def __init__(self, kirish_olchami, sinflar_soni):
        super().__init__()
        self.qatlamlar = nn.Sequential(
            nn.Linear(kirish_olchami, 128),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(128, 64),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(64, sinflar_soni),
        )

    def forward(self, x):
        return self.qatlamlar(x)


model = Tarmoq(kirish_olchami=64, sinflar_soni=10)
print(model)