Давайте рассмотрим библиотеку 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 🤖

Давайте рассмотрим Apache Kafka, который является ключевым компонентом в экосистеме Data Operations. Kafka - это распределенное потоковое сообщество данных, которое широко используется для построения реестров событий и архитектур микросервисов.

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

- Распределенное потоковое сообщество данных
- Хранение сообщений в журнале (log)
- Потоковая обработка данных
- Масштабируемость и отказоустойчивость
- Поддержка шаблонов потребления (consumer groups)
- Интеграция с другими системами и технологиями

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

Вот пример кода на Java для создания простого производителя сообщений в Kafka:

import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.serialization.StringSerializer;

import java.util.Properties;
import java.util.concurrent.ExecutionException;

public class SimpleKafkaProducer {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // Настройки подключения к Kafka
        Properties props = new Properties();
        props.put("bootstrap.servers", "localhost:9092");
        props.put("key.serializer", StringSerializer.class.getName());
        props.put("value.serializer", StringSerializer.class.getName());

        // Создаем производителя сообщений
        KafkaProducer<String, String> producer = new KafkaProducer<>(props);

        // Отправляем сообщения
        for (int i = 0; i < 10; i++) {
            ProducerRecord<String, String> record = new ProducerRecord<>("topic-name", "key-" + i, "value-" + i);
            producer.send(record).get(); // Ждем подтверждения отправки
            System.out.println("Sent message: " + record.value());
        }

        // Закрываем производителя
        producer.close();
    }
}

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

1. Мы создаем объект Properties, чтобы настроить подключение к Kafka.

2. Устанавливаем адрес bootstrap-сервера Kafka.

3. Указываем сериализаторы для ключей и значений сообщений.

4. Создаем экземпляр KafkaProducer, передавая настройки.

5. Отправляем 10 сообщений в топик "topic-name".

6. Ждем подтверждения отправки каждого сообщения.

7. Закрываем производителя после завершения работы.

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

- Масштабируемость: легко масштабировать производительность и хранение данных.
- Независимость от времени: сообщения сохраняются в журнале, что позволяет обработать их позже.
- Гарантируемое доставка: сообщения гарантированно доставляются потребителям.
- Потоковая обработка: поддерживает потоковую обработку данных в реальном времени.
- Широкая интеграция: хорошо интегрируется с другими системами и технологиями.

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

1. Используйте шаблоны потребления (consumer groups) для распределения нагрузки между потребителями.

2. Настройте параметры acks для обеспечения надежной доставки сообщений.

3. Используйте компрессию для оптимизации использования дискового пространства.

4. Реализуйте механизм повторных попыток для обработки ошибок при отправке или получении сообщений.

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

6. Используйте теги (tags) для группировки связанных сообщений.

7. Регулярно мониторьте метрики производительности и доступности системы.

Apache Kafka - это мощный инструмент для построения архитектур микросервисов и реестров событий. Он предоставляет высокую степень гибкости и масштабируемости, что делает его отличным выбором для проектов, требующих обработки больших объемов данных в реальном времени.

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

Давайте рассмотрим Apache Hadoop, который является ключевым компонентом в экосистеме Data Operations. Hadoop - это распределенная система хранения и обработки больших объемов данных.

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

- Распределенная система хранения данных (Hadoop Distributed File System - HDFS)
- Распределенная система обработки данных (MapReduce)
- Масштабируемость и отказоустойчивость
- Поддержка различных типов данных и форматов
- Интеграция с другими системами и технологиями

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

Вот пример кода на Java для выполнения word count на Hadoop:

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

public class WordCount {
    public static void main(String[] args) throws Exception {
        Configuration conf = new Configuration();
        
        Job job = Job.getInstance(conf, "word count");
        job.setJarByClass(WordCount.class);
        
        FileInputFormat.addInputPath(job, new Path(args[1]));
        FileOutputFormat.setOutputPath(job, new Path(args[2]));
        
        job.setMapperClass(Map.class);
        job.setReducerClass(Reduce.class);
        
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);
        
        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }
    
    public static class Map extends Mapper<Object, Text, Text, IntWritable> {
        private final static IntWritable one = new IntWritable(1);
        
        public void map(Object key, Text value, Context context) throws IOException, InterruptedException {
            String[] words = value.toString().split("\\s+");
            for (String word : words) {
                context.write(new Text(word), one);
            }
        }
    }
    
    public static class Reduce extends Reducer<Text, IntWritable, Text, IntWritable> {
        public void reduce(Text key, Iterable<IntWritable> values, Context context)
                throws IOException, InterruptedException {
            int sum = 0;
            for (IntWritable val : values) {
                sum += val.get();
            }
            context.write(key, new IntWritable(sum));
        }
    }
}

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

1. Мы создаем конфигурацию Hadoop и задание job.

2. Устанавливаем входные и выходные пути для задания.

3. Определяем классы Map и Reduce для обработки данных.

4. В методе map мы разделяем слова в каждой строке и отправляем их в контекст.

5. В методе reduce мы суммируем количество появлений каждого слова.

6. Задание запускается с помощью waitForCompletion.

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

- Масштабируемость: легко масштабировать обработку больших объемов данных.
- Независимость от времени: данные сохраняются в журнале, что позволяет обработать их позже.
- Гарантируемая доставка: данные гарантированно хранятся на диске.
- Потоковая обработка: поддерживает потоковую обработку данных в реальном времени.
- Широкая интеграция: хорошо интегрируется с другими системами и технологиями.

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

1. Используйте YARN (Yet Another Resource Negotiator) для управления ресурсами кластера.

2. Настройте параметры репликации для обеспечения отказоустойчивости.

3. Используйте компрессию для оптимизации использования дискового пространства.

4. Реализуйте механизм повторных попыток для обработки ошибок при чтении или записи данных.

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

6. Регулярно мониторьте метрики производительности и доступности системы.

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

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

Подпишись 👉🏻 @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 🤖

Вот пример кода на 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 🤖

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 над координатами.

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

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

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

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

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

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

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


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

XGBoost (eXtreme Gradient Boosting) — это мощная библиотека для градиентного бустинга деревьев решений, широко используемая в задачах машинного обучения, особенно на соревнованиях по анализу данных. Ниже представлен пример использования XGBoost для классификации на основе известного набора данных Iris.

import xgboost as xgb
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# Загрузка набора данных Iris
iris = load_iris()
X = iris.data
y = iris.target

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

# Создание объекта DMatrix для XGBoost
dtrain = xgb.DMatrix(X_train, label=y_train)
dtest = xgb.DMatrix(X_test, label=y_test)

# Настройки параметров модели
params = {
    'objective': 'multi:softmax',  # многоклассовая классификация
    'num_class': 3,                # количество классов
    'max_depth': 4,                # максимальная глубина дерева
    'eta': 0.3,                    # скорость обучения
    'eval_metric': 'merror'        # метрика ошибки для оценки модели
}

# Тренировка модели
num_round = 100
bst = xgb.train(params, dtrain, num_round)

# Предсказание на тестовых данных
y_pred = bst.predict(dtest)

# Оценка точности модели
accuracy = accuracy_score(y_test, y_pred)
print(f'Accuracy: {accuracy * 100:.2f}%')

# Вывод важности признаков
xgb.plot_importance(bst)

### Описание кода:
1. Загрузка данных: Используется встроенный набор данных Iris из библиотеки sklearn, который содержит информацию о трех классах ирисов (setosa, versicolor, virginica), каждый из которых представлен четырьмя признаками (длина и ширина чашелистика и лепестка).

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

3. Создание DMatrix: XGBoost использует специальный формат данных DMatrix, который оптимизирован для работы с большими объемами данных.

4. Настройки параметров модели: Параметры модели задаются с помощью словаря params. В данном случае модель настроена для многоклассовой классификации (`multi:softmax`) с тремя классами (`num_class: 3`), глубиной дерева 4 и скоростью обучения 0.3.

5. Обучение модели: Модель обучается на данных dtrain в течение 100 итераций.

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

7. Важность признаков: Используя функцию plot_importance, можно визуализировать важность признаков, которые использовала модель.

Этот пример показывает, как просто можно создать и обучить модель на основе XGBoost для задачи классификации с использованием набора данных Iris.

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

Вот пример кода на Python, который демонстрирует, как создать и обучить модель машинного обучения с использованием библиотеки SciKit-Learn. В данном примере используется логистическая регрессия для классификации на основе известного набора данных Iris.

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix

# Загрузка набора данных Iris
iris = load_iris()
X = iris.data  # Признаки
y = iris.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)

# Создание и обучение модели логистической регрессии
model = LogisticRegression(random_state=42, max_iter=200)
model.fit(X_train, y_train)

# Предсказание на тестовых данных
y_pred = model.predict(X_test)

# Оценка точности модели
accuracy = accuracy_score(y_test, y_pred)
print(f'Accuracy: {accuracy * 100:.2f}%')

# Вывод подробного отчета по классификации
print("Classification Report:")
print(classification_report(y_test, y_pred, target_names=iris.target_names))

# Вывод матрицы ошибок (confusion matrix)
print("Confusion Matrix:")
print(confusion_matrix(y_test, y_pred))

### Описание кода:
1. Загрузка данных: Используется встроенный набор данных Iris из библиотеки sklearn. Этот набор данных состоит из четырех признаков (длина и ширина чашелистика и лепестка) для каждого из трех видов ирисов (setosa, versicolor, virginica).

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

3. Стандартизация данных: Признаки нормализуются с помощью StandardScaler, что улучшает производительность моделей, чувствительных к масштабам данных, таких как логистическая регрессия.

4. Создание и обучение модели: Создается модель логистической регрессии LogisticRegression, которая затем обучается на стандартизованных обучающих данных. Параметр max_iter=200 задает максимальное количество итераций для сходимости алгоритма.

5. Предсказание: Модель делает предсказания на тестовых данных.

6. Оценка точности: Вычисляется точность модели с использованием функции accuracy_score, которая показывает процент правильно предсказанных классов.

7. Отчет по классификации: Выводится подробный отчет по классификации с использованием функции classification_report, который включает такие метрики, как точность (precision), полнота (recall) и F1-меру.

8. Матрица ошибок: Также выводится матрица ошибок с помощью функции confusion_matrix, которая показывает, как часто объекты одного класса были ошибочно классифицированы как объекты другого класса.

Этот пример демонстрирует основные этапы работы с данными, создания и оценки модели с использованием SciKit-Learn, одной из самых популярных библиотек для машинного обучения в Python.

Подпишись 👉🏻 @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 класса вина
    
    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = self.fc3(x)
        return x

# Инициализация модели, функции потерь и оптимизатора
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)

        # Обратный проход и оптимизация
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

    if (epoch+1) % 10 == 0:
        print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')

# Тестирование модели
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()

    print(f'Accuracy: {100 * correct / total:.2f}%')

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

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

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

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

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

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

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

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

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

👉 Самый быстрый курс по Python, чтобы начать программировать с нуля. Для тех кому некогда, но очень надо выучить язык программирования Python или подтянуть базу перед собеседованием 🤖

🔥 Персональная скидка 975 рублей по промокоду TG_KD_PYTHON действует только до конца недели 🔥

👆 Курс можно подарить кому угодно 😎

🎁 Вечный доступ и поддержка внутри курса 🤝

by @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 🤖

Вот пример кода на 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 с использованием библиотеки Seaborn для визуализации данных из базы данных SQLite:

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

pip install sqlite3 seaborn pandas matplotlib

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

import sqlite3
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

# Подключение к базе данных 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()

# Визуализация данных с использованием Seaborn
plt.figure(figsize=(8, 6))
sns.barplot(x='product', y='quantity', data=df)

# Добавление заголовка
plt.title('Количество проданных товаров')

# Отображение графика
plt.show()

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

1. Статистически достоверные визуализации: Seaborn построен на базе Matplotlib и предоставляет высокоуровневый API для создания визуализаций, специально ориентированных на статистический анализ данных.

2. Гибкость в работе с данными: Seaborn поддерживает работу с Pandas DataFrame, что делает его отличным инструментом для визуализации данных, загруженных из различных источников, включая базы данных.

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

4. Простота в работе с категориальными и числовыми переменными: Seaborn предоставляет множество встроенных функций для отображения категориальных данных (например, barplot, countplot) и корреляций между переменными.

5. Взаимодействие с Matplotlib: Seaborn может интегрироваться с Matplotlib, что позволяет настроить графики более гибко, используя все возможности Matplotlib для изменения стиля и оформления.

### Объяснение:
1. SQLite используется для хранения и работы с данными, связанными с продажами.
2. Pandas загружает данные из базы данных в DataFrame, что делает их удобными для последующей визуализации.
3. Seaborn создаёт столбчатую диаграмму, которая визуализирует количество проданных товаров по каждому продукту.
4. Matplotlib используется для управления отображением графиков (например, добавление заголовков и отображение диаграмм).

Этот код создаёт простую и эстетически приятную диаграмму с помощью Seaborn, которая демонстрирует количество проданных товаров для каждого продукта.

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

👉👉👉 Грядет большое повышение цен на курсы ИТ на Stepik 👆👆👆

👉 Покупайте по старым ценам пока есть возможность, доступ к курсам и всем обновлениям курса останется у Вас навсегда 🔥

Наши курсы:

👉 Python: самый быстрый курс 🔥

Перед Вами самый быстрый курс по Python, тут есть все что нужно чтобы начать программировать на Python. Для тех кому некогда, но очень надо выучить Python или подтянуть базу перед собеседованием. Уже 389 позитивных оценок уроков. Мы отвечаем на все ваши комментарии и вопросы в курсе.

👉 Python в нескучных примерах (50)

Для того чтобы научится программировать - нужно много программировать, совершать ошибки, править код, узнавать как можно сделать код лучше, делать код лучше, и продолжать программировать. В этом курсе нет воды, только большое количество примеров на основании которых вы можете написать много своего кода и стать лучше. Рекомендуем брать пример и расширять его, и свою версию выкладывать на github, потом вы сможете использовать эти переработанные примеры как свое портфолио для фриланса или для найма на работу.

👉 JavaScript: самый быстрый курс 🔥

Перед Вами самый быстрый курс по JavaScript, тут есть все что нужно чтобы начать программировать на JS. Для тех кому некогда, но очень надо выучить JS или подтянуть базу перед собеседованием. Мы отвечаем на все ваши комментарии и вопросы в курсе.

👉 Язык программирования BrainFuck или ВыносМозга!

Очень простой с точки зрения кол-ва команд и одновременно сложный для программирования язык, потому что читабельнность почти нулевая. Assembler по сравнению с ним просто Easy. Зато это мега язык для понимания того как работают любая программа на уровне скомпилированного кода - всем рекомендую кодить раз в неделю на BrainFuck и все остальные языки будут Very Easy.

Наши программы:

👉 Junior Python Developer 🔥🔥

Этот набор курсов является специализацией для того чтобы с 0 дойти до уровня Junior Python Developer. Особенность включенных курсов в том что первый дает всю базу в максимально короткий срок, а второй дает возможность попробовать множество различных библиотек и нескучных идей кода.

👉 Junior FullStack Developer: Python+JavaScript (быстрый курс) 🔥🔥🔥

Этот набор курсов является специализацией для того чтобы с 0 дойти до уровня Junior FullStack Developer. Программа для тех кому некогда, но очень надо выучить JS и Python или подтянуть базу перед собеседованием. Мы отвечаем на все ваши комментарии и вопросы в курсе.

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