10

import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim

# Генерируем данные
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([0, 1, 1, 0])

# Функция активации и ее производная
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def sigmoid_derivative(x):
    return x * (1 - x)

# Функция обучения нейросети
def train_nn(X, y, learning_rate, iterations):
    input_layer_neurons = X.shape[1]
    output_neurons = 1

    # Инициализация весов
    weights = np.random.uniform(size=(input_layer_neurons, output_neurons))

    for i in range(iterations):
        # Прямое распространение
        hidden_layer_input = np.dot(X, weights)
        hidden_layer_output = sigmoid(hidden_layer_input)

        # Обратное распространение
        error = y.reshape(-1,1) - hidden_layer_output
        d_error = error * sigmoid_derivative(hidden_layer_output)

        # Обновление весов
        weights += learning_rate * np.dot(X.T, d_error)

    return weights

learning_rates = [0.01, 0.1, 0.0001]
iterations = 100

for learning_rate in learning_rates:
    weights = train_nn(X, y, learning_rate, iterations)
    print(f"Learning Rate: {learning_rate}")
    print("Trained Weights:", weights)

# Перенатренировка с оптимальным learning_rate
optimal_learning_rate = 0.1
optimal_iterations = 1000

optimal_weights = train_nn(X, y, optimal_learning_rate, optimal_iterations)
print("nOptimal Weights:", optimal_weights)
print("\n")
print("\n")
print("\n")
# Функция для вычисления градиента
def compute_gradient(inputs, weights):
    return np.dot(inputs, weights)

# Функция для обновления весов
def update_weights(weights, gradient, learning_rate):
    return weights + learning_rate * gradient

# Данные для обучения
inputs = np.array([[0.1, 0.2], [0.3, 0.4], [0.5, 0.6]])
targets = np.array([0.3, 0.7, 0.9])

# Инициализация весов и скорости обучения
weights = np.array([0.1, 0.2])
learning_rate = 0.01

# Обучение
for i in range(1000):
    for j in range(len(inputs)):
        gradient = compute_gradient(inputs[j], weights)
        weights = update_weights(weights, gradient, learning_rate)

# Предсказание
predictions = np.dot(inputs, weights)
print("Predictions:", predictions)
print("\n")
print("\n")
print("\n")
# Функция для вычисления градиента
def compute_gradient(x):
    return 2*x

# Инициализация начального значения веса
w = 0.5

# Задание значения inp
inp = 200

# Коэффициент обучения
alpha = 0.1

# Количество итераций
epochs = 20

# Обучение модели с градиентным спуском
for i in range(epochs):
    gradient = compute_gradient(inp)
    w = w - alpha * gradient
    print("Iteration:", i+1, " Weight:", w)
print("\n")
print("\n")
print("\n")


def neural_network(input, weights):
    return np.dot(input, weights)


def grad_descent(input, true_predictions, alpha=0.01, num_iterations=100):
    weights = np.random.rand(len(input[0]), len(true_predictions[0]))

    for i in range(num_iterations):
        preds = neural_network(input, weights)
        error = preds - true_predictions
        loss = np.mean(error ** 2)
        gradient = 2 * np.dot(input.T, error) / len(input)
        weights -= alpha * gradient

    return weights


input_data = np.array([[1.2, 0.7],
                       [-0.3, 0.5],
                       [3.0, 0.1],
                       [-0.1, 1.0]])
true_predictions = np.array([[75, 82],
                             [56, 70],
                             [142, 128],
                             [67, 85]])

new_true_predictions = np.array([[70, 90]])

weights = grad_descent(input_data, new_true_predictions)

print(weights)
print("\n")
print("\n")
print("\n")


# Функция активации (сигмоид)
def sigmoid(x):
    return 1 / (1 + np.exp(-x))


# Производная функции активации
def sigmoid_derivative(x):
    return x * (1 - x)


# Функция среднеквадратичное отклонение
def get_error(true_value, prediction_value):
    return np.sqrt(np.mean((true_value - prediction_value)))