DA @easy_ds
Showing posts older than #2591 · Back to latest
from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
# Загрузка данных
data = load_boston()
X = data.data
y = data.target
# Разделение данных на обучающую и тестовую выборку
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Создание и обучение модели
model = LinearRegression()
model.fit(X_train, y_train)
# Предсказание и оценка модели
y
_pred = model.predict(X_test)
print("MSE:", mean_squared_error(y_test, y_pred))
import numpy as np
import pandas as pd
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import roc_auc_score, precision_recall_curve, auc
# Создание несбалансированного набора данных
X, y = make_classification(n_samples=1000, n_features=20, n_informative=2, n_redundant=10,
n_clusters_per_class=1, weights=[0.99], flip_y=0, random_state=42)
# Разделение на обучающую и тестовую выборки
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Обучение модели логистической регрессии
model = LogisticRegression()
model.fit(X_train, y_train)
# Предсказание вероятностей
y_scores = model.predict_proba(X_test)[:, 1]
# Вычисление ROC AUC
roc_auc = roc_auc_score(y_test, y_scores)
# Вычисление Precision-Recall AUC
precision, recall, _ = precision_recall_curve(y_test, y_scores)
pr_auc = auc(recall, precision)
print(f"ROC AUC: {roc_auc}")
print(f"Precision-Recall AUC: {pr_auc}")
IQR = Q3 - Q1
IQR = Q3 - Q1 = 16.5 - 4.5 = 12
import numpy as np
# Данные
data = [1, 3, 3, 6, 7, 8, 9, 15, 18, 19]
# Вычисление квартилей
Q1 = np.percentile(data, 25)
Q2 = np.percentile(data, 50)
Q3 = np.percentile(data, 75)
# Вычисление IQR
IQR = Q3 - Q1
print(f"Первый квартиль (Q1): {Q1}")
print(f"Медиана (Q2): {Q2}")
print(f"Третий квартиль (Q3): {Q3}")
print(f"Интерквартильный размах (IQR): {IQR}")
# Выявление выбросов
lower_bound = Q1 - 1.5 * IQR
upper_bound = Q3 + 1.5 * IQR
print(f"Границы для выбросов: {lower_bound} и {upper_bound}")
outliers = [x for x in data if x < lower_bound or x > upper_bound]
print(f"Выбросы: {outliers}")
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
import pandas as pd
# Загрузка данных
data = pd.read_csv('data.csv')
# Стандартизация данных
scaler = StandardScaler()
scaled_data = scaler.fit_transform(data)
# Применение PCA
pca = PCA(n_components=2) # Уменьшение до 2 компонент
principal_components = pca.fit_transform(scaled_data)
# Преобразование обратно в DataFrame
pca_df = pd.DataFrame(data=principal_components, columns=['PC1', 'PC2'])
import hashlib
def hash_string(input_string):
# Использование SHA-256 хэш-функции
sha_signature = hashlib.sha256(input_string.encode()).hexdigest()
return sha_signature
# Пример хэширования строки
input_str = "Hello, world!"
hashed_str = hash_string(input_str)
print(f"Хэш-значение для '{input_str}' с использованием SHA-256: {hashed_str}")
import numpy as np
def gradient_descent(x, y, lr=0.01, epochs=100):
m, b = 0.1, 0.1 # начальная инициализация параметров
n = len(x) # количество данных
for _ in range(epochs):
f = y - (m*x + b)
# Обновление m и b
m -= lr * (-2 * x.dot(f).sum() / n)
b -= lr * (-2 * f.sum() / n)
return m, b
# Демонстрация на простых данных
x = np.array([1,
2, 3, 4, 5])
y = np.array([5, 7, 9, 11, 13])
m, b = gradient_descent(x, y)
print("Наклон m:", m, "Пересечение b:", b)
from sklearn.linear_model import Ridge
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error
# Пример данных
X = ... # Ваши данные признаков
y = ... # Целевая переменная
# Разделение данных на обучающий и тестовый наборы
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Модель с L2 регуляризацией (Ridge)
model = Ridge(alpha=1.0)
model.fit(X_train, y_train)
# Предсказание и оценка
y_pred_train = model.predict(X_train)
y_pred_test = model.predict(X_test)
train_error = mean_squared_error(y_train, y_pred_train)
test_error = mean_squared_error(y_test, y_pred_test)
print(f'Training Error: {train_error}')
print(f'Test Error: {test_error}')
import torch.nn as nn
import torch.optim as optim
model = nn.Linear(10, 1)
optimizer = optim.SGD(model.parameters(), lr=0.01, weight_decay=0.001) # L2-регуляризация
p. В тестовом режиме нейроны работают в полную силу, но с весами, скорректированными на p. import torch.nn as nn
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.fc1 = nn.Linear(10, 50)
self.dropout = nn.Dropout(p=0.5) # Выключаем 50% нейронов
self.fc2 = nn.Linear(50, 1)
def forward(self, x):
x = self.fc1(x)
x = self.dropout(x)
x = self.fc2(x)
return x
import torch.nn as nn
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.fc1 = nn.Linear(10, 50)
self.bn1 = nn.BatchNorm1d(50) # Нормализация
self.fc2 = nn.Linear(50, 1)
def forward(self, x):
x = self.fc1(x)
x = self.bn1(x)
x = self.fc2(x)
return x
import torchvision.transforms as transforms
transform = transforms.Compose([
transforms.RandomHorizontalFlip(),
transforms.RandomRotation(10),
transforms.ColorJitter(brightness=0.2, contrast=0.2),
transforms.ToTensor()
])
from torch.optim.lr_scheduler import ReduceLROnPlateau
scheduler = ReduceLROnPlateau(optimizer, mode='min', patience=5)
scipy или seaborn.seaborn import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
# Пример данных
data = np.random.normal(loc=0, scale=1, size=1000)
# Оценка плотности ядра (KDE)
sns.kdeplot(data, shade=True)
plt.title("Kernel Density Estimation (KDE)")
plt.show()
scipy import numpy as np
from scipy.stats import gaussian_kde
import matplotlib.pyplot as plt
# Пример данных
data = np.random.normal(loc=0, scale=1, size=1000)
# Оценка плотности ядра (KDE)
kde = gaussian_kde(data)
# Создание новых данных на основе KDE
x = np.linspace(min(data), max(data), 1000)
kde_values = kde(x)
plt.plot(x, kde_values)
plt.title("Kernel Density Estimation (KDE)")
plt.show()
# Генерация новых данных на основе оцененного распределения
new_samples = kde.resample(size=1000).T[0]
plt.hist(new_samples, bins=30, density=True, alpha=0.5, label='Generated Data')
sns.kdeplot(data, shade=True, label='Original Data')
plt.title("Generated Data vs Original Data")
plt.legend()
plt.show()
import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import norm
# Пример данных
data = np.random.normal(loc=0, scale=1, size=1000)
# Оценка параметров нормального распределения
mu, std = norm.fit(data)
# Генерация новых данных
new_data = np.random.normal(loc=mu, scale=std, size=1000)
plt.hist(new_data, bins=30, density=True, alpha=0.5, label='Generated Data')
xmin, xmax = plt.xlim()
x = np.linspace(xmin, xmax, 100)
p = norm.pdf(x, mu, std)
plt.plot(x, p, 'k', linewidth=2, label='Fitted Distribution')
plt.title("Generated Data with Fitted Distribution")
plt.legend()
plt.show()