ax = fig.add_axes([0.1, 0.1, 0.8, 0.8])

fig = plt.figure(figsize=(8, 8))

# График 1: минимальные отступы (основной размер)
ax1 = fig.add_axes([0.0, 0.0, 0.8, 0.8])  # График занимает большую часть фигуры, отступов нет
ax1.set_title('Отступы: [0.0, 0.0, 0.8, 0.8]')

# График 2: отступы увеличены
ax2 = fig.add_axes([0.3, 0.3, 0.5, 0.5])  # График с увеличенными отступами
ax2.set_title('Отступы: [1.3, 1.3, 0.5, 0.5]')

plt.show()

xx = np.arange(0, 2 * np.pi, 0.01) #значения, по которым будут вычисляться точки на оси x

2π соответствует одному полному циклу синусоиды (360 градусов в радианах)

yy = np.sin(xx)

▫️Функция np.sin в библиотеке NumPy позволяет вычислить синус для массива значений x, таких как np.arange(0, 2 * np.pi, 0.01)

▫️Она возвращает массив значений
y, который соответствует значениям синуса для каждого x

 ax.plot(xx, yy, label='y = sin(x)')

ax.set_title('График синусоиды') # заголовок графика
ax.set_xlabel('x (угол в радианах)') # подпись оси x
ax.set_ylabel('y (значение синуса)') # подпись оси y
ax.legend() # Отображает легенду, которая берет текст из label (пункт 5)
plt.show() # сам график

import matplotlib.pyplot as plt
import numpy as np


fig = plt.figure(figsize=(5, 4))
ax = fig.add_axes([0.1, 0.1, 0.8, 0.8])


xx = np.arange(0, 2 * np.pi, 0.01)  # От 0 до 2π с шагом 0.01
yy = np.sin(xx)


ax.plot(xx, yy, label='y = sin(x)')

ax.set_title('График синусоиды')
ax.set_xlabel('x (угол в радианах)')
ax.set_ylabel('y (значение синуса)')
ax.legend()

plt.show()

x — площадь дома, y — цена дома

from matplotlib import pyplot as plt #Иморт библиотек

plt.scatter([50, 60, 70, 100], [10, 30, 40, 50], 50, 'g', 'o', alpha = 0.8) #В ппервых двух квадратных скобках это наши координаты x и y. Число 50 - это размер точек, g - green (цвет), o - Форма точек (круг). alpha = 0.8 - Прозрачность точек

plt.show() 

import numpy as np

X = np.array([[1, 50], [1, 60], [1, 70], [1, 100]])

X

array([[  1,  50],
       [  1,  60],
       [  1,  70],
       [  1, 100]])

Вектор Y записывается в виде столбца

import numpy as np

Y = np.array([[10], [30], [40], [50]])

Y

array([[  1,  50],
       [  1,  60],
       [  1,  70],
       [  1, 100]])

w₀ — свободный член, который отвечает за сдвиг линии регрессии

w₁, w₂ — веса (коэффициенты) для признаков x₁, x₂

Транспонированная матрица — это матрица, которая получается из исходной путём перестановки строк и столбцов. Другими словами, чтобы получить транспонированную матрицу, необходимо взять каждую строчку по очереди и переписать её в виде столбца, не меняя порядка следования.

###
Берем блок кода с прошлого поста (там мы выводили матрицу для X)
###

import numpy as np

X = np.array([[1, 50], [1, 60], [1, 70], [1, 100]]) # Создание массива (получаем матрицу 4 на 2)

X_T_X = (X.T).dot(X) 

###
Транспанируем матрицу X.T. X.T — это транспонированная версия матрицы X. Строки становятся столбцами, а столбцы — строками.
###

X_T_X

array([[    4,   280],
       [  280, 21000]])

[[  1,   1,   1,   1],
 [ 50,  60,  70, 100]] 

[[  1,  50],
 [  1,  60],
 [  1,  70],
 [  1, 100]]

Кстати, че за единицы? Я про единицы, которые рядом с нашими признаками:

Единицы в первом столбце нужны, чтобы модель линейной регрессии учитывала свободный член 🟰w₀🟰

⚙️ Единицы нужны, чтобы линейная регрессия не привязывалась к точке (0, 0) и могла сдвигать прямую вверх или вниз. Грубо говоря, гайс, мы включаем столбец единиц чтобы включить w₀ (свободный член)

w₀ — это сдвиг прямой вверх или вниз
w₁ — это наклон прямой

import numpy as np

# Матрица X
X = np.array([[1, 50], [1, 60], [1, 70], [1, 100]])

# Транспонированная матрица X
X_T = X.T

# Печатаем результаты
print("Исходная матрица X:")
print(X)

print("\nТранспонированная матрица X.T:")
print(X_T)

# Считаем X_T_X
X_T_X = X_T.dot(X)
print("\nПроизведение X.T @ X:")
print(X_T_X)

import numpy as np

X = np.array([[1, 50], [1, 60], [1, 70], [1, 100]])

X_T_X = (X.T).dot(X)
X_T_X

from numpy.linalg import inv

X_T_X_inverted = inv(X_T_X)

X_T_X_inverted  

w = X_T_X_inverted.dot(X.T).dot(Y)
print('w_1=%.5f, w_2=%.3f' % (w[0][0], w[1][0]))

import numpy as np
from numpy.linalg import inv

# Матрица X и вектор Y
X = np.array([[1, 50], [1, 60], [1, 70], [1, 100]])
Y = np.array([[10], [30], [40], [50]])

# Вычисление X^T * X
X_T_X = (X.T).dot(X)

# Обратная матрица (X^T * X)^-1
X_T_X_inverted = inv(X_T_X)

# Вычисление w = (X^T * X)^-1 * X^T * Y
w = X_T_X_inverted.dot(X.T).dot(Y)

print('w_1=%.5f, w_2=%.3f' % (w[0][0], w[1][0]))

w_1=-17.50000, w_2=0.714

# имортируем библиотеки
import numpy as np 
from numpy.linalg import inv
import matplotlib.pyplot as plt

# Наши данные
X = np.array([[1, 50], [1, 60], [1, 70], [1, 100]]) # площадь дома (входной признак)
Y = np.array([[10], [30], [40], [50]]) # цена дома (целевая переменная)

# Матрица X_T_X - транспанированная матрица
X_T_X = (X.T).dot(X) # Матричное провзедение Xᵀ * X (вычисляет коэффициенты регресии)
X_T_X_inverted = inv(X_T_X) # Находим обратную матрицу для полученного значения Xᵀ * X

w = X_T_X_inverted.dot(X.T).dot(Y) # Здесь мы прописали саму формулу

print('w_1=%.5f, w_2=%.3f' % (w[0][0], w[1][0]))

print('w_1=%.5f, w_2=%.3f' % (w[0][0], w[1][0]))

w₀ = -17,5
w₁ = 0.714

margin = 10
X_min = X[:, 1].min() - margin
X_max = X[:, 1].max() + margin

margin = 10

X_min = X[:, 1].min() - margin

import numpy as np 
from numpy.linalg import inv # Имортируем функцию для нахождения обратной матрицы

X = np.array([[1, 50], [1, 60], [1, 70], [1, 100]]) # матрица (объекты - признаки)
Y = np.array([[10], [30], [40], [50]]) #Вектор

#(X.T).dot(X) - это просто для понимания, как мы умножили транспонированную мтарицу на саму себя же 

w = inv( # Обратную транспонированную матрицу умножим на X
    (X.T).dot(X)
).dot( # Дальше умножим на транспонированную матрицу X.T
    X.T
).dot( # И умножим на вектор Y
    Y
)