PostgreSQL и MongoDB: два подхода к управлению данными
В мире баз данных существует множество решений, каждое из которых подходит для определённых задач. Два популярных представителя — это PostgreSQL и MongoDB. Они представляют собой разные подходы к хранению и обработке данных: реляционный и документоориентированный. Рассмотрим их основные особенности.
PostgreSQL: мощь реляционных баз данных
PostgreSQL — это объектно-реляционная система управления базами данных (СУБД) с открытым исходным кодом. Она поддерживает SQL (Structured Query Language) и предлагает широкие возможности для работы со структурированными данными. PostgreSQL известна своей надёжностью, поддержкой транзакций ACID (атомарность, согласованность, изолированность, долговечность) и расширяемостью.
Преимущества PostgreSQL:
Поддержка сложных запросов и JOIN-операций.
Высокая согласованность данных.
Возможность создания пользовательских типов данных и функций.
Поддержка JSON и JSONB для работы с полуструктурированными данными.
Широкие возможности для аналитики и работы с большими объёмами данных.
from sqlalchemy import create_engine
# Параметры подключения к базе данных
host = 'localhost:5432' # Например, localhost
database = 'first_db'
user = 'postgres'
password = 'password'
# Создаем строку подключения и создаем engine
engine = create_engine(f'postgresql://{user}:{password}@{host}/{database}')
# Устанавливаем подключение к базе данных
connection = engine.raw_connection()
connection
# Напишем SQL-запрос
query = "SELECT * FROM *" # Замените на свой запрос
# Загружаем данные в DataFrame
df = pd.read_sql(query, connection)PostgreSQL отлично подходит для приложений, где важна целостность данных, сложные запросы и структурированные схемы, например, финансовые системы, CRM или ERP-системы.
MongoDB: гибкость документоориентированного подхода
MongoDB — это NoSQL-база данных, которая хранит данные в формате BSON (бинарный JSON). В отличие от PostgreSQL, MongoDB не требует строгой схемы данных, что делает её более гибкой для работы с быстро изменяющимися или неструктурированными данными.
Преимущества MongoDB:
Гибкость схемы: данные могут быть изменены без необходимости пересоздания таблиц.
Высокая производительность для операций чтения и записи.
Масштабируемость: поддержка горизонтального масштабирования через шардирование.
Удобство работы с иерархическими и вложенными данными.
Подходит для работы с большими объёмами данных в реальном времени.
MongoDB часто используется в приложениях, где важна скорость разработки и гибкость, например, в социальных сетях, IoT-платформах или системах с большим количеством пользовательских данных.
from pymongo import MongoClient
# подключаемся к нашему клиенту
client = MongoClient("mongodb://localhost:27017/")
# выбираем базу данных
mydb = client['db']
# выводим список доступных таблиц
mydb.list_collection_names()
# создаем коллекции данных по таблице
collection1 = mydb['tb']
# Извлекаем данные из коллекций
data1 = list(collection1.find())
# Преобразуем данные в DataFrame
df1 = pd.DataFrame(data1)PostgreSQL vs MongoDB: что выбрать?
Выбор между PostgreSQL и MongoDB зависит от задач вашего проекта. Если вам нужна строгая структура данных, сложные запросы и высокая согласованность, PostgreSQL будет лучшим выбором. Если же ваши данные часто меняются, имеют сложную иерархию или вам нужно быстро масштабироваться, MongoDB может оказаться более подходящим решением.
В некоторых случаях эти две системы могут использоваться вместе, например, PostgreSQL для хранения структурированных данных, а MongoDB — для работы с неструктурированными или полуструктурированными данными.
Таким образом, и PostgreSQL, и MongoDB имеют свои сильные стороны, и правильный выбор зависит от специфики вашего проекта.
import pandas as pd
import numpy as np
from collections import Counter
from tqdm.notebook import tqdm
from sklearn.ensemble import RandomForestRegressor, VotingRegressor
from catboost import CatBoostRegressor
from sklearn.neighbors import KNeighborsRegressor
from lightgbm import LGBMRegressor
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder, StandardScaler, MinMaxScaler, RobustScaler
from sklearn.decomposition import PCA
from sklearn.model_selection import PredefinedSplit
from sklearn.model_selection import GridSearchCV
df = pd.read_csv('train.zip', compression='zip', sep='\t')
df
df.duplicated().sum()
df.columns
# # mb
# df = df[[col for col in df.columns if not col.startswith('mb_')]]
# df
df.info()
Counter(df.target)
df.isna().sum().sum()
# # df.fillna(df.mean(), inplace=True)
# df.fillna(df.median(), inplace=True)
# df.isna().sum().sum()
# df1 = df[df.target == 1]
# df1
# df0 = df[df.target == 0]
# df0
# # удаление выбросов
# for col in df.columns[:-1]:
# mean = df1[col].mean()
# std = df1[col].std()
# threshold = 3
# df1 = df1[(df1[col] < mean + threshold * std) & (df1[col] > mean - threshold * std)]
# df1
# # удаление выбросов
# for col in df.columns[:-1]:
# mean = df0[col].mean()
# std = df0[col].std()
# threshold = 3
# df0 = df0[(df0[col] < mean + threshold * std) & (df0[col] > mean - threshold * std)]
# df0
# df = pd.concat([df1, df0], axis=0)
# df
Counter(df.target)
test = pd.read_csv('test.zip', compression='zip', sep='\t', index_col=0)
test
# # mb
# test = test[[col for col in test.columns if not col.startswith('mb_')]]
# test
test.isna().sum().sum()
# # test.fillna(test.mean(), inplace=True)
# test.fillna(df.median(), inplace=True)
# test.isna().sum().sum()
X = df.drop(['target'], axis=1)
X
# scaler = StandardScaler()
# X = pd.DataFrame(data=scaler.fit_transform(X))
# X
# pca = PCA(n_components=30)
# X = pd.DataFrame(data=pca.fit_transform(X))
# X
y = df.target
y
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, stratify=y)
# knn
knn = KNeighborsRegressor(n_jobs=-1)
knn.fit(X, y)
#Проведем оценку модели
# mae = mean_absolute_error(knn.predict(X_test), y_test)
# mse = mean_squared_error(knn.predict(X_test), y_test)
# r2 = r2_score(knn.predict(X_test), y_test)
# print(mae,mse,r2)
# catboost
cat = CatBoostRegressor(iterations=1000000, od_wait=1000, task_type='GPU')
cat.fit(X_train, y_train, verbose=200, eval_set=(X_test, y_test))
# cat = CatBoostRegressor()
# grid = {'depth':[None, 7, 8, 9],
# 'iterations':[15000],
# 'od_wait':[1000],
# 'task_type':['GPU']}
# cat.grid_search(grid,
# X=X,
# y=y,
# verbose=200,
# train_size=0.8)
# cat = CatBoostRegressor(iterations=15000, task_type='GPU')
# cat.fit(X, y, verbose=200, eval_set=(X_test, y_test))
#Проведем оценку модели
mae = mean_absolute_error(cat.predict(X_test), y_test)
mse = mean_squared_error(cat.predict(X_test), y_test)
r2 = r2_score(cat.predict(X_test), y_test)
print(mae,mse,r2)
# lgbm
lgbm = LGBMRegressor(n_jobs=-1)
lgbm.fit(X_train, y_train, eval_set=(X_test, y_test))
#Проведем оценку модели
mae = mean_absolute_error(lgbm.predict(X_test), y_test)
mse = mean_squared_error(lgbm.predict(X_test), y_test)
r2 = r2_score(lgbm.predict(X_test), y_test)
print(mae,mse,r2)
# voting ensemle
vot = VotingRegressor(
estimators=[
('knn', KNeighborsRegressor(n_jobs=-1)),
('catboost', CatBoostRegressor(verbose=0)),
('lgbm', LGBMRegressor(n_jobs=-1)),
],
voting='hard',
n_jobs=-1,
verbose=True
)
vot.fit(X_train, y_train)
mae = mean_absolute_error(vot.predict(X_test), y_test)
mse = mean_squared_error(vot.predict(X_test), y_test)
r2 = r2_score(vot.predict(X_test), y_test)
print(mae,mse,r2)
# create submit
test
sub = pd.read_csv('sample_submission.csv', index_col=0)
sub
X_pred = test
# X_pred = scaler.transform(X_pred)
# X_pred = pca.fit_transform(X_pred)
pred =cat.predict(X_pred)
sub['target'] = pred
sub
sub.to_csv('sub.csv')