Вот интересный и полезный лайфхак на чистом Python: реализация LRU (Least Recently Used) кэша без использования дополнительных библиотек.

### Что это?
LRU-кэш сохраняет результаты вызовов функций для ускорения последующих вычислений. Если кэш переполняется, удаляется самый "старый" элемент.

---

### Реализация LRU-кэша:

```

from collections import deque

class LRUCache:
def __init__(self, capacity: int):
self.cache = {} # Хранение данных
self.order = deque() # Порядок использования
self.capacity = capacity

# Пример использования
cache = LRUCache(3)
cache.put(1, "A") # Добавляем ключ 1
cache.put(2, "B") # Добавляем ключ 2
cache.put(3, "C") # Добавляем ключ 3

print(cache.get(1)) # "A" - обновляем порядок ключа 1
cache.put(4, "D") # Добавляем ключ 4, удаляем самый старый (ключ 2)

print(cache.get(2)) # -1 (удалён из-за переполнения)
print(cache.get(3)) # "C"
print(cache.get(4)) # "D"

```

---

### Как это работает:
1. Кэш:
- Хранит значения по ключам.
- self.cache — словарь для хранения данных.
2. Порядок использования:
- deque отслеживает порядок добавления/обновления ключей.
- Если кэш переполняется, удаляется элемент, добавленный раньше всех.
3. Методы:
- get: Возвращает значение по ключу и обновляет порядок.
- put: Добавляет новый элемент, удаляя самый старый при необходимости.

---

### Чем полезно:
- Позволяет ускорить функции, повторяющие одни и те же вычисления.
- Это компактная реализация кэша без использования библиотек, которая полезна в ограниченных средах.

Подпишись 👉🏻 @KodduuPython 🤖

Познакомимся с редкой библиотекой для задач производительности и удобства работы с многопоточностью — joblib. Она полезна для эффективного параллельного выполнения задач и кеширования результатов.

---

### Установка joblib
Если библиотека не установлена:

```

pip install joblib

```

---

### Пример использования: параллельная обработка
Создадим пример, который выполняет вычисления факториалов для большого набора чисел с использованием многопоточности.

```

from joblib import Parallel, delayed
import math
import time

# Функция для вычисления факториала
def compute_factorial(n):
return math.factorial(n)

def main():
numbers = range(100000, 100010) # Список больших чисел для вычисления факториала

if __name__ == "__main__":
main()

```

### Объяснение:
1. Параллельное выполнение:
- Parallel(n_jobs=\-1) использует все доступные ядра процессора для вычислений.
- delayed(compute_factorial) указывает функцию и её аргументы для выполнения.

1. Результаты:
   - Код вычисляет факториалы для чисел от 100,000 до 100,009.
   - Вместо вывода самих чисел (очень большие), выводится количество цифр в результатах.

2. Время выполнения:
   - Параллельное выполнение значительно ускоряет обработку по сравнению с последовательным.

### Преимущества joblib:
- Простота использования.
- Поддержка автоматического распараллеливания.
- Возможность кеширования результатов для экономии времени на повторных вычислениях.

Подпишись 👉🏻 @KodduuPython 🤖

Вот пример кода на Python с использованием библиотеки Altair для визуализации данных из базы данных SQLite:

### 1. Установите необходимые библиотеки:

```

pip install sqlite3 altair pandas

```

### 2. Пример кода:

```

import sqlite3
import pandas as pd
import altair as alt

# Подключение к базе данных SQLite
conn = sqlite3.connect('example.db')

# Создание таблицы и вставка данных (если еще не создана)
conn.execute('''
CREATE TABLE IF NOT EXISTS sales (
id INTEGER PRIMARY KEY,
product TEXT,
quantity INTEGER,
price REAL
)
''')
conn.execute('''
INSERT INTO sales (product, quantity, price) VALUES
('Product A', 10, 25.50),
('Product B', 20, 15.75),
('Product C', 5, 100.00)
''')
conn.commit()

# Загрузка данных из базы данных в DataFrame
df = pd.read_sql_query("SELECT * FROM sales", conn)

# Закрытие соединения
conn.close()

# Визуализация данных с использованием Altair
chart = alt.Chart(df).mark_bar().encode(
x='product:N', # категориальная переменная для оси X
y='quantity:Q', # количественная переменная для оси Y
tooltip=['product', 'quantity', 'price'] # отображение данных при наведении
).properties(
title='Количество проданных товаров'
)

# Отображение графика в Jupyter Notebook
chart.display()

# Если нужно вывести график в HTML-файл
# chart.save('sales_chart.html')

```

### Особенности Altair:

1. Декларативный синтаксис: Altair использует декларативный подход к визуализации данных. Это означает, что вы описываете, что хотите отобразить, а Altair сам управляет деталями рендеринга, что упрощает процесс создания сложных графиков.

2. Интерактивность: Altair позволяет легко добавлять интерактивные элементы к графикам, такие как зум, панорамирование, фильтрация данных и отображение подсказок (как в примере с tooltip).

3. Интеграция с Pandas: Altair работает непосредственно с Pandas DataFrame, что упрощает обработку данных и их визуализацию.

4. Автоматическая настройка масштабов и осей: Altair автоматически настраивает оси и масштаб графиков, исходя из типа данных, что помогает быстро строить корректные визуализации без необходимости ручной настройки.

5. Поддержка сложных графиков: Altair отлично справляется как с простыми визуализациями (столбчатые диаграммы, линейные графики), так и с более сложными (тепловые карты, диаграммы рассеивания, многослойные визуализации).

### Объяснение:
1. SQLite: используется для хранения данных о продажах. В данном примере создается таблица с информацией о продуктах, их количестве и цене.
2. Pandas: загружает данные из базы данных в DataFrame, что делает их удобными для последующей визуализации.
3. Altair: используется для создания столбчатой диаграммы. На оси x отображаются названия продуктов, на оси y — количество проданных единиц. При наведении курсора на столбцы появляется информация о продукте, количестве и цене.
4. Интерактивность: Altair легко поддерживает интерактивные элементы, такие как всплывающие подсказки при наведении на элементы диаграммы.

Этот код создаёт простую и интерактивную столбчатую диаграмму с использованием Altair, которая отлично подходит для анализа и представления данных в Jupyter Notebook или в HTML-файле.

Подпишись ?? @KodduuPython ?

Вот пример кода на Python с использованием библиотеки Plotly для визуализации данных из базы данных SQLite:

### 1. Установите необходимые библиотеки:

```

pip install sqlite3 plotly pandas

```

### 2. Пример кода:

```

import sqlite3
import pandas as pd
import plotly.express as px

# Подключение к базе данных SQLite
conn = sqlite3.connect('example.db')

# Создание таблицы и вставка данных (если еще не создана)
conn.execute('''
CREATE TABLE IF NOT EXISTS sales (
id INTEGER PRIMARY KEY,
product TEXT,
quantity INTEGER,
price REAL
)
''')
conn.execute('''
INSERT INTO sales (product, quantity, price) VALUES
('Product A', 10, 25.50),
('Product B', 20, 15.75),
('Product C', 5, 100.00)
''')
conn.commit()

# Загрузка данных из базы данных в DataFrame
df = pd.read_sql_query("SELECT * FROM sales", conn)

# Закрытие соединения
conn.close()

# Визуализация данных с использованием Plotly
fig = px.bar(df, x='product', y='quantity', title='Количество проданных товаров')
fig.show()

```

### Объяснение:
1. Подключение к базе данных SQLite с помощью sqlite3.
2. Создается таблица с информацией о продажах и вставляются данные, если их еще нет.
3. Данные загружаются в DataFrame с помощью pandas.
4. Используется библиотека Plotly (plotly.express) для создания гистограммы, отображающей количество проданных товаров по каждому продукту.

Этот код визуализирует количество проданных товаров с помощью столбчатой диаграммы.

Подпишись ?? @KodduuPython ?

Давайте рассмотрим пример использования PyTorch с другим известным набором данных — Wine Dataset (Винный набор данных). Этот набор данных содержит информацию о химическом составе вин, и задача заключается в классификации вина на три различных типа.

Вот пример кода:

```

import torch
import torch.nn as nn
import torch.optim as optim
from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from torch.utils.data import DataLoader, TensorDataset

# Загрузка данных Wine
wine = load_wine()
X = wine.data
y = wine.target

# Разделение данных на обучающую и тестовую выборки
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Нормализация данных
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

# Преобразование данных в тензоры PyTorch
X_train_tensor = torch.tensor(X_train, dtype=torch.float32)
y_train_tensor = torch.tensor(y_train, dtype=torch.long)
X_test_tensor = torch.tensor(X_test, dtype=torch.float32)
y_test_tensor = torch.tensor(y_test, dtype=torch.long)

# Создание датасетов и загрузчиков данных
train_dataset = TensorDataset(X_train_tensor, y_train_tensor)
test_dataset = TensorDataset(X_test_tensor, y_test_tensor)

train_loader = DataLoader(dataset=train_dataset, batch_size=16, shuffle=True)
test_loader = DataLoader(dataset=test_dataset, batch_size=16, shuffle=False)

# Определение нейронной сети
class WineNN(nn.Module):
def __init__(self):
super(WineNN, self).__init__()
self.fc1 = nn.Linear(13, 64)
self.fc2 = nn.Linear(64, 32)
self.fc3 = nn.Linear(32, 3) # 3 класса вина

# Инициализация модели, функции потерь и оптимизатора
model = WineNN()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# Обучение модели
num_epochs = 50
for epoch in range(num_epochs):
model.train()
for i, (inputs, labels) in enumerate(train_loader):
# Прямой проход
outputs = model(inputs)
loss = criterion(outputs, labels)

# Тестирование модели
model.eval()
with torch.no_grad():
correct = 0
total = 0
for inputs, labels in test_loader:
outputs = model(inputs)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()

```

### Описание кода:

1. Загрузка данных: Используется набор данных Wine из sklearn, который содержит 13 признаков для каждого образца вина, включая такие характеристики, как содержание алкоголя, кислотность и т.д. Целевая переменная имеет три возможных класса.

2. Разделение и нормализация данных: Данные делятся на обучающую и тестовую выборки и нормализуются с помощью StandardScaler.

3. Создание датасетов и загрузчиков данных: Преобразование данных в тензоры PyTorch и создание DataLoader для удобного перебора данных.

4. Определение нейронной сети: Создается простая нейронная сеть с двумя скрытыми слоями, которая принимает на вход 13 признаков и выводит вероятность принадлежности к одному из трех классов.

5. Обучение модели: Модель обучается с использованием Adam-оптимизатора и функции потерь CrossEntropyLoss. Тренировочный процесс повторяется в течение 50 эпох.

6. Тестирование модели: После обучения модель тестируется на тестовых данных, и вычисляется точность классификации.

Этот пример демонстрирует основные этапы работы с PyTorch: от подготовки данных и создания модели до обучения и тестирования на новом наборе данных.

Подпишись ?? @KodduuPython ?

Theano был одной из первых популярных библиотек для машинного обучения, с тех пор он был заменен более современными и удобными инструментами, такими как TensorFlow и PyTorch. Тем не менее, вот пример кода, который обучает простую нейронную сеть на синтетическом наборе данных:

```

import numpy as np
import theano
import theano.tensor as T

# Генерация синтетического набора данных
np.random.seed(0)
X_train = np.random.randn(1000, 2)
y_train = np.logical_xor(X_train[:, 0] > 0, X_train[:, 1] > 0)
y_train = y_train.astype(int)

# Входные и выходные переменные
X = T.dmatrix('X')
y = T.ivector('y')

# Инициализация весов и смещений
W1 = theano.shared(np.random.randn(2, 3), name='W1')
b1 = theano.shared(np.zeros(3), name='b1')
W2 = theano.shared(np.random.randn(3, 2), name='W2')
b2 = theano.shared(np.zeros(2), name='b2')

# Прямое распространение (forward pass)
z1 = T.nnet.relu(T.dot(X, W1) + b1)
z2 = T.nnet.softmax(T.dot(z1, W2) + b2)

# Функция потерь (кросс-энтропия)
loss = T.mean(T.nnet.categorical_crossentropy(z2, y))

# Градиенты
dW1, db1, dW2, db2 = T.grad(loss, [W1, b1, W2, b2])

# Функция обучения
learning_rate = 0.01
train = theano.function(
inputs=[X, y],
outputs=loss,
updates=((W1, W1 - learning_rate * dW1),
(b1, b1 - learning_rate * db1),
(W2, W2 - learning_rate * dW2),
(b2, b2 - learning_rate * db2))
)

# Функция предсказания
predict = theano.function(inputs=[X], outputs=T.argmax(z2, axis=1))

# Обучение модели
for epoch in range(100):
current_loss = train(X_train, y_train)
if epoch % 10 == 0:
print(f'Epoch {epoch}: Loss = {current_loss:.4f}')

# Проверка точности на обучающем наборе
predictions = predict(X_train)
accuracy = np.mean(predictions == y_train)
print(f'Accuracy: {accuracy * 100:.2f}%')

```

### Описание кода:
1. Создание синтетического набора данных: В примере используется набор данных, сгенерированный с помощью функции np.random.randn. Данные представляют собой двумерные точки, где метки определяются по операции XOR над координатами.

1. Инициализация весов и смещений: Веса и смещения для двух слоев сети инициализируются случайными значениями.

2. Прямое распространение: Используется функция активации ReLU для скрытого слоя и softmax для выходного слоя.

3. Функция потерь: В качестве функции потерь используется кросс-энтропия.

4. Обучение: Обновление весов происходит с использованием стохастического градиентного спуска. Theano вычисляет градиенты автоматически с помощью функции T.grad.

5. Обучение модели: Модель обучается в течение 100 эпох с выводом значения функции потерь каждые 10 эпох.

6. Оценка точности: Модель оценивается на обучающем наборе данных, и выводится точность.

Этот пример демонстрирует базовые принципы построения и обучения простой нейронной сети с использованием Theano.

Подпишись ?? @KodduuPython ?

Вот пример кода на Python, который демонстрирует, как создать и обучить простую нейронную сеть для задачи классификации изображений с использованием библиотеки Keras. В данном примере используется датасет MNIST, содержащий изображения рукописных цифр от 0 до 9.

```

import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.datasets import mnist
from tensorflow.keras.utils import to_categorical

# Загрузка и подготовка данных
(x_train, y_train), (x_test, y_test) = mnist.load_data()

# Нормализация данных (переводим значения пикселей в диапазон от 0 до 1)
x_train = x_train.astype('float32') / 255
x_test = x_test.astype('float32') / 255

# Изменение формы данных (добавление канала)
x_train = x_train.reshape((x_train.shape[0], 28, 28, 1))
x_test = x_test.reshape((x_test.shape[0], 28, 28, 1))

# Преобразование меток в категориальный формат
y_train = to_categorical(y_train, 10)
y_test = to_categorical(y_test, 10)

# Создание модели
model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))

model.add(layers.Flatten())
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(10, activation='softmax'))

# Компиляция модели
model.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy'])

# Обучение модели
model.fit(x_train, y_train, epochs=5, batch_size=64, validation_split=0.2)

# Оценка модели на тестовых данных
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f'Test accuracy: {test_acc:.4f}')

```

### Описание кода:
1. Загрузка данных: Используемый датасет MNIST загружается через функцию mnist.load_data(). Он разделен на обучающий и тестовый наборы данных.
2. Предобработка данных: Пиксели изображений нормализуются в диапазон от 0 до 1, а метки классов преобразуются в формат one-hot encoding с помощью функции to_categorical.
3. Создание модели: Нейронная сеть включает несколько слоев:
- Сверточные слои (Conv2D) с функцией активации ReLU.
- Слои подвыборки (MaxPooling2D).
- Полносвязный слой (Dense) и выходной слой с функцией активации softmax для классификации.
4. Компиляция модели: Используется оптимизатор Adam и функция потерь categorical_crossentropy.
5. Обучение модели: Модель обучается на тренировочных данных с разделением на обучающую и валидационную выборки.
6. Оценка модели: Точность модели оценивается на тестовых данных.

Этот пример показывает основные шаги создания и обучения модели с использованием Keras и TensorFlow.

Подпишись ?? @KodduuPython ?

Вот пример кода на Python с использованием библиотеки JAX:

### Ключевые моменты

- JAX предоставляет NumPy-подобный интерфейс с автоматическим дифференцированием.
- Функция jit позволяет компилировать код на GPU или TPU.
- grad используется для вычисления градиентов.
- vmap применяет функцию ко всем элементам массива одновременно.

### Реализация кода

```

import jax.numpy as jnp
from jax import grad, jit, vmap

# Создаем простую нейронную сеть
def predict(params, inputs):
for W, b in params:
outputs = jnp.dot(inputs, W) + b
inputs = jnp.tanh(outputs) # активация танх
return outputs # без активации на последнем слое

# Определяем функцию потерь
def loss(params, inputs, targets):
preds = predict(params, inputs)
return jnp.sum((preds - targets)**2)

# Компилируем и оптимизируем функцию потерь
loss_compiled = jit(loss)

# Вычисляем градиент потерь
grad_loss = jit(grad(loss))

# Векторизуем вычисление градиентов
per_example_grads = jit(vmap(grad_loss, in_axes=(None, 0, 0)))

# Пример использования
params = [(jnp.array([[2], [3]]), jnp.array([1])),
((jnp.array([[4], [5]]), jnp.array([2]))]
inputs = jnp.array([[0.5], [0.3]])
targets = jnp.array([[0.6], [0.4]])

print("Потери:", loss_compiled(params, inputs, targets))
print("Градиенты:", grad_loss(params, inputs, targets))
print("Векторизованные градиенты:", per_example_grads(params, inputs, targets))

```

### Обзор кода и лучшие практики

Этот пример демонстрирует основные возможности JAX:

1. Мы использовали jax.numpy вместо стандартного numpy для обеспечения совместимости с JAX.
2. Функция predict представляет собой простой слой нейронной сети.
3. Функция loss определяет целевую функцию (в данном случае квадратичное отклонение).
4. Мы применили jit к функциям loss и grad_loss для оптимизации их выполнения.
5. vmap использовался для векторизации вычисления градиентов по отдельным примерам.
6. Код демонстрирует, как JAX может быть использован для быстрого вычисления и оптимизации нейронных сетей.

Этот пример показывает, как JAX может значительно ускорить вычисления, особенно при работе с большими объемами данных или сложными алгоритмами машинного обучения.

Подпишись ?? @KodduuPython ?

Давайте рассмотрим библиотеку Koalas, которая является частью экосистемы Data Operations и предоставляет высокоуровневый интерфейс для работы с данными в Apache Spark.

### Основные характеристики Koalas

- Высокоуровневая библиотека для работы с данными в Apache Spark
- Совместимость с pandas API, что упрощает переход с локальных данных на облачные решения
- Поддержка операционных систем Windows, macOS и Linux
- Работа с различными источниками данных, включая файловые системы, базы данных и другие системы хранения данных

### Пример использования Koalas

Вот пример кода, демонстрирующий основные возможности Koalas:

```

import databricks.koalas as ks
import pandas as pd

# Создание DataFrame с фиктивными данными
data = {
'date': pd.date_range(start='2023-01-01', periods=100),
'value': np.random.randn(100)
}
df = pd.DataFrame(data)

# Конвертация в Koalas DataFrame
kdf = ks.from_pandas(df)

# Агрегация данных
result = kdf.groupby('date').agg({'value': ['mean', 'std']})

# Визуализация результатов
result.plot(kind='line', x='date', y=['value_mean', 'value_std'])
plt.title('Mean and Standard Deviation of Values Over Time')
plt.xlabel('Date')
plt.ylabel('Value')
plt.legend(title='Metric')
plt.show()

# Сохранение в формате Parquet
kdf.to_parquet('data.parquet')

# Чтение из Parquet файла
kdf_read = ks.read_parquet('data.parquet')
print(kdf_read.head())

```

### Объяснение кода

1. Мы импортируем библиотеку Koalas и pandas.

2. Создаем обычный pandas DataFrame с фиктивными данными.

3. Конвертируем этот DataFrame в Koalas DataFrame с помощью ks.from_pandas().

4. Выполняем группировку и агрегацию данных, используя методы, похожие на те, которые используются в pandas.

5. Визуализируем результаты с помощью matplotlib.

6. Сохраняем Koalas DataFrame в формате Parquet для последующего использования.

7. Читаем сохраненный файл обратно в Koalas DataFrame.

### Преимущества использования Koalas

- Совместимость с pandas API: разработчики, привыкшие к pandas, смогут быстро освоиться с Koalas.
- Высокая производительность: Koalas оптимизирован для работы с большими объемами данных в Apache Spark.
- Гибкость: поддерживает широкий спектр операций с данными, включая группировку, сортировку и агрегацию.
- Интеграция с другими инструментами Databricks: легко интегрируется с другими компонентами платформы Databricks.

### Лучшие практики при работе с Koalas

1. Используйте ks.from_pandas() для конвертации существующих pandas DataFrame в Koalas DataFrame.

2. Применяйте методы агрегации, такие как groupby().agg(), для эффективной обработки данных.

3. Используйте встроенные функции для визуализации, например plot(), для быстрого создания графиков.

4. Экспериментируйте с разными форматами хранения данных, такими как Parquet, для оптимизации производительности.

5. При работе с большими объемами данных учитывайте возможность кеширования результатов для улучшения производительности.

Koalas предоставляет удобный способ работы с данными в Apache Spark, сохраняя при этом высокий уровень абстракции и совместимость с pandas. Это делает его отличным выбором для проектов, требующих обработки больших объемов данных в облачных средах.

Подпишись ?? @KodduuPython ?