Работа с датасетом FER2013 для распознавания эмоций человека с помощью нейронной сети включает несколько ключевых этапов: загрузку данных, их предобработку, построение модели нейронной сети, обучение и оценку модели. Ниже приведён пример кода, демонстрирующий эти этапы.

Шаг 1: Установка необходимых библиотек
Для начала убедитесь, что у вас установлены необходимые библиотеки: tensorflow, numpy, pandas, и matplotlib. Вы можете установить их с помощью pip:

pip install tensorflow numpy pandas matplotlib

Шаг 2: Загрузка и предобработка данных

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from tensorflow.keras.utils import to_categorical
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from sklearn.model_selection import train_test_split

# Загрузка данных
data = pd.read_csv('fer2013.csv')
pixels = data['pixels'].tolist()
width, height = 48, 48
faces = []

for pixel_sequence in pixels:
    face = [int(pixel) for pixel in pixel_sequence.split(' ')]
    face = np.asarray(face).reshape(width, height)
    faces.append(face.astype('float32'))

faces = np.asarray(faces)
faces = np.expand_dims(faces, -1)

emotions = pd.get_dummies(data['emotion']).to_numpy()

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

# Нормализация данных
X_train /= 255
X_test /= 255

# Аугментация данных (опционально)
data_generator = ImageDataGenerator(featurewise_center=False,
                                    featurewise_std_normalization=False,
                                    rotation_range=10,
                                    width_shift_range=0.1,
                                    height_shift_range=0.1,
                                    zoom_range=.1,
                                    horizontal_flip=True)

Шаг 3: Создание модели нейронной сети

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout, BatchNormalization

model = Sequential()

model.add(Conv2D(64, kernel_size=(3, 3), activation='relu', input_shape=(width, height, 1)))
model.add(Conv2D(64, kernel_size=(3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))

model.add(Conv2D(128, kernel_size=(3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))

model.add(Conv2D(256, kernel_size=(3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dropout(0.5))

model.add(Dense(256, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(7, activation='softmax'))

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

model.summary()

Шаг 4: Обучение модели

batch_size = 64
epochs = 50

# Обучение модели
history = model.fit(data_generator.flow(X_train, y_train, batch_size),
                    steps_per_epoch=len(X_train) / batch_size,
                    epochs=epochs,
                    verbose=1,
                    validation_data=(X_test, y_test))

Шаг 5: Оценка модели

# Оценка модели на тестовых данных
test_loss, test_accuracy = model.evaluate(X_test, y_test)
print('Test accuracy:', test_accuracy)

Заметки
- Убедитесь, что у вас есть файл fer2013.csv в вашей рабочей директории.

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

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

Мы будем использовать библиотеку TensorFlow для построения автоэнкодера, который обучается на "нормальных" данных и затем используется для выявления аномалий.

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

pip install tensorflow numpy pandas matplotlib

Шаг 2: Подготовка данных
Этот код подразумевает, что у вас уже есть набор данных временных рядов. Для простоты мы будем использовать случайно сгенерированные данные.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.preprocessing import MinMaxScaler
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, LSTM, Dropout, RepeatVector, TimeDistributed

# Генерация случайных данных
np.random.seed(0)
time_steps = 100
samples = 1000
data = np.random.normal(0, 0.5, (samples, time_steps))

# Нормализация данных
scaler = MinMaxScaler()
data_normalized = scaler.fit_transform(data)

### Шаг 3: Создание модели автоэнкодера

# Размерность входных данных
n_features = 1

# Построение модели автоэнкодера
model = Sequential([
    LSTM(128, activation='relu', input_shape=(time_steps, n_features), return_sequences=True),
    Dropout(0.2),
    LSTM(64, activation='relu', return_sequences=False),
    RepeatVector(time_steps),
    LSTM(64, activation='relu', return_sequences=True),
    Dropout(0.2),
    LSTM(128, activation='relu', return_sequences=True),
    TimeDistributed(Dense(n_features))
])

model.compile(optimizer='adam', loss='mse')
model.summary()

Шаг 4: Обучение модели

# Подготовка данных для обучения
data_expanded = np.expand_dims(data_normalized, axis=2)

# Обучение
model.fit(data_expanded, data_expanded, epochs=50, batch_size=32, validation_split=0.1, shuffle=True)

Шаг 5: Обнаружение аномалий

# Предсказания модели
reconstructions = model.predict(data_expanded)
reconstruction_errors = np.mean(np.abs(data_expanded - reconstructions), axis=1)
threshold = np.percentile(reconstruction_errors, 95)

# Определение аномалий
anomalies = reconstruction_errors > threshold

Шаг 6: Визуализация результатов

# Визуализация ошибок реконструкции
plt.hist(reconstruction_errors, bins=50)
plt.axvline(x=threshold, color='r', linestyle='--')
plt.title('Распределение ошибок реконструкции')
plt.xlabel('Ошибка реконструкции')
plt.ylabel('Количество')
plt.show()

# Визуализация аномалий
plt.plot(data[0])
plt.title('Пример временного ряда')
plt.xlabel('Время')
plt.ylabel('Значение')
plt.show()

print("Обнаружено аномалий:", np.sum(anomalies))

Этот код представляет базовую структуру системы обнаружения аномалий во временных рядах. В зависимости от ваших данных и требований, вы можете настроить модель и методы обработки данных.

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

Создание модели для демонстрации работы наночастиц в Python может быть выполнено с использованием библиотеки Matplotlib для визуализации и NumPy для математических расчетов. Мы можем создать простую симуляцию, которая демонстрирует случайное движение наночастиц в двумерном пространстве, например, для имитации броуновского движения.

В этом примере мы создадим анимацию, где наночастицы будут случайным образом перемещаться в пределах заданной области.

Пример кода

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation

# Параметры симуляции
num_particles = 50
steps = 1000
xlim = (0, 100)
ylim = (0, 100)

# Инициализация позиций наночастиц
positions = np.random.rand(num_particles, 2) * np.array([xlim[1], ylim[1]])

# Функция для обновления позиции каждой частицы
def update(frame_num, positions, scatter):
    delta = np.random.randn(num_particles, 2)
    positions += delta
    positions = np.clip(positions, [xlim[0], ylim[0]], [xlim[1], ylim[1]])
    scatter.set_offsets(positions)
    return scatter,

# Создание фигуры для анимации
fig, ax = plt.subplots()
scatter = ax.scatter(positions[:, 0], positions[:, 1])
ax.set_xlim(xlim)
ax.set_ylim(ylim)
ax.set_title("Симуляция движения наночастиц")
anim = animation.FuncAnimation(fig, update, fargs=(positions, scatter), frames=steps, interval=50, blit=True)

# Отображение анимации
plt.show()

### Описание кода
1. Импорт библиотек: Используем numpy для работы с массивами и matplotlib для визуализации.

2. Инициализация параметров симуляции: Задаем количество частиц, количество шагов, и пределы области.

3. Инициализация позиций наночастиц: Располагаем наночастицы случайным образом внутри заданной области.

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

5. Создание и запуск анимации: Создаем анимацию с использованием FuncAnimation, где update - функция, вызываемая на каждом шаге анимации.

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

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

Создание визуализации, демонстрирующей Стандартную модель физики элементарных частиц, в рамках простого программного кода на Python может быть сложной задачей. Стандартная модель физики элементарных частиц — это теория, описывающая три из четырех фундаментальных сил природы (за исключением гравитации) и классифицирующая все известные элементарные частицы. Однако мы можем создать простую визуализацию, которая представляет различные частицы и их характеристики, например, их группы (кварки, лептоны, бозоны).

Пример кода

import matplotlib.pyplot as plt
import pandas as pd

# Данные о частицах
data = {
    "Particle": ["Up quark", "Down quark", "Electron", "Neutrino", "Photon", "W boson", "Z boson", "Higgs boson"],
    "Type": ["Quark", "Quark", "Lepton", "Lepton", "Boson", "Boson", "Boson", "Boson"],
    "Charge": ["+2/3", "-1/3", "-1", "0", "0", "+/-1", "0", "0"],
    "Mass": ["2.3 MeV/c²", "4.8 MeV/c²", "0.511 MeV/c²", "<1 eV/c²", "0", "80.4 GeV/c²", "91.2 GeV/c²", "125.1 GeV/c²"]
}

# Создание DataFrame
df = pd.DataFrame(data)

# Визуализация
fig, ax = plt.subplots(figsize=(10, 6))
ax.axis('tight')
ax.axis('off')
ax.table(cellText=df.values, colLabels=df.columns, cellLoc = 'center', loc='center')

plt.title("Standard Model of Particle Physics")
plt.show()

Описание кода
1. Импорт библиотек: Используем matplotlib для создания визуализации и pandas для удобной работы с данными.

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

3. Создание DataFrame: Преобразуем наши данные в pandas.DataFrame для удобства отображения.

4. Визуализация данных: Используем функцию table из Matplotlib для создания таблицы, которая отображает информацию о частицах.

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

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

Для создания визуализации Таблицы Менделеева в Python, мы можем использовать библиотеки matplotlib и pandas. Мы создадим таблицу, где каждый элемент будет представлен в виде ячейки с основной информацией, такой как символ, атомный номер и атомная масса.

Пример кода

import matplotlib.pyplot as plt
import pandas as pd

# Данные о некоторых элементах
elements = {
    "Атомный номер": [1, 2, 6, 7, 8, 26],
    "Символ": ["H", "He", "C", "N", "O", "Fe"],
    "Имя": ["Водород", "Гелий", "Углерод", "Азот", "Кислород", "Железо"],
    "Атомная масса": [1.008, 4.002602, 12.011, 14.007, 15.999, 55.845]
}

# Создание DataFrame
df = pd.DataFrame(elements)

# Визуализация в виде таблицы
fig, ax = plt.subplots(figsize=(12, 4))
ax.axis('off')
table = ax.table(cellText=df.values, colLabels=df.columns, loc='center', cellLoc='center')
table.auto_set_font_size(False)
table.set_fontsize(12)
table.scale(1.2, 1.5)

plt.title("Фрагмент Таблицы Менделеева")
plt.show()

Описание кода
1. Импорт библиотек: Используем matplotlib для визуализации и pandas для удобного представления данных.

2. Подготовка данных: Создаем словарь с данными об элементах. Здесь приведены данные лишь о нескольких элементах, но вы можете расширить этот список.

3. Создание DataFrame: Преобразуем наш словарь данных в pandas.DataFrame.

4. Визуализация: Используем matplotlib для создания визуализации в виде таблицы. Настройки шрифта и размера таблицы подгоняются для удобства просмотра.

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

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

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

Пример кода

import random
import time

def print_welcome():
    print("Добро пожаловать в игру 'Волк ловит яйца'!")
    print("Волк может стоять в одной из четырех позиций (1, 2, 3, 4).")
    print("Ваша задача - вводить номер позиции, чтобы поймать яйцо.")
    print("Если вы пропустите яйцо, игра закончится.\n")

def get_egg_position():
    return random.randint(1, 4)

def main():
    print_welcome()
    score = 0
    wolf_position = 2
    try:
        while True:
            egg_position = get_egg_position()
            print(f"Яйцо падает в позицию {egg_position}. Введите позицию волка:")
            try:
                wolf_position = int(input("> "))
                if wolf_position == egg_position:
                    score += 1
                    print(f"Вы поймали яйцо! Ваш счет: {score}")
                else:
                    print(f"Вы пропустили яйцо. Игра окончена. Ваш финальный счет: {score}")
                    break
            except ValueError:
                print("Пожалуйста, введите число от 1 до 4.")
    except KeyboardInterrupt:
        print("\nИгра окончена.")

if __name__ == "__main__":
    main()

Описание игры
- Игра начинается с приветственного сообщения и объяснения правил.
- Яйцо "падает" в одну из четырех позиций, выбранную случайным образом.
- Игрок должен ввести номер позиции, куда хочет переместить волка, чтобы поймать яйцо.
- Если волк находится в той же позиции, что и падающее яйцо, игрок зарабатывает очко.
- Если игрок вводит неверную позицию или пропускает яйцо, игра заканчивается.
- Игра продолжается, пока игрок не допустит ошибку.
- Игрок может прервать игру в любой момент, нажав Ctrl+C.

Этот код демонстрирует простую текстовую игру, выполненную в консольном режиме. Она может быть дополнена и усовершенствована по вашему усмотрению, например, добавлением уровней сложности или более сложными правилами для движения яиц.

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

Для тех кто не успел, еще одна супер скидка на наш курс на stepik!

Создание VPN-сервера на Python — это сложная задача, которая выходит за рамки базового программирования из-за необходимости в глубоких знаниях сетевых технологий и безопасности. Также требуются административные привилегии для конфигурации сетевых интерфейсов и маршрутизации.

Однако, я могу показать вам, как создать простой TCP-сервер и клиент на Python, который можно использовать как отправную точку для изучения основ создания сетевых приложений. Для создания полноценного VPN-сервера вам потребуется использовать дополнительные инструменты и протоколы, такие как OpenVPN или WireGuard, и гораздо более сложная настройка.

Пример простого TCP-сервера и клиента на Python

TCP-сервер:

import socket

def start_server(port=12345):
    # Создаем сокет
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.bind(('0.0.0.0', port))
    server_socket.listen()

    print(f"Сервер запущен и слушает порт {port}...")

    # Принимаем соединение
    client_socket, client_address = server_socket.accept()
    print(f"Подключение от {client_address}")

    # Получаем и отправляем данные
    while True:
        message = client_socket.recv(1024).decode()
        if not message:
            break
        print(f"Получено от клиента: {message}")
        client_socket.send(f"Эхо: {message}".encode())

    client_socket.close()
    server_socket.close()

if __name__ == '__main__':
    start_server()

TCP-клиент:

import socket

def start_client(server_ip='127.0.0.1', port=12345):
    # Подключаемся к серверу
    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    client_socket.connect((server_ip, port))

    print(f"Подключено к серверу {server_ip} на порту {port}")

    # Отправка и получение данных
    try:
        while True:
            message = input("Введите сообщение: ")
            client_socket.send(message.encode())
            response = client_socket.recv(1024).decode()
            print(f"Ответ сервера: {response}")
    except KeyboardInterrupt:
        print("\nОтключение от сервера...")

    client_socket.close()

if __name__ == '__main__':
    start_client()

Описание
- TCP-сервер: Слушает входящие соединения и отправляет обратно эхо полученных сообщений.
- TCP-клиент: Подключается к серверу, отправляет сообщения и получает их эхо.

Этот код лишь демонстрирует основы сетевого взаимодействия в Python и не представляет собой VPN-сервер. Создание настоящего VPN-сервера требует более глубоких знаний в области сетевых технологий и безопасности, а также использования специализированных библиотек и инструментов.

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

Рассмотрим сценарий, где мы анализируем набор данных, содержащий информацию о продажах в разных магазинах. Мы выполним следующие задачи:

1. Загрузим данные и проведем их первичную обработку.
2. Рассчитаем средние продажи по каждому магазину.
3. Визуализируем данные, показывая тенденции продаж в зависимости от времени года.

Предположим, у нас есть CSV-файл sales_data.csv, который содержит колонки Store, Date, и Sales.

Вот примерный код:

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

# Загрузка и предварительная обработка данных
data = pd.read_csv('sales_data.csv')
data['Date'] = pd.to_datetime(data['Date'])

# Вычисление средних продаж по магазинам
average_sales = data.groupby('Store')['Sales'].mean()

# Визуализация
plt.figure(figsize=(10, 6))
sns.barplot(x=average_sales.index, y=average_sales.values)
plt.title('Средние продажи по магазинам')
plt.xlabel('Магазин')
plt.ylabel('Средние продажи')
plt.xticks(rotation=45)
plt.show()

# Анализ продаж в зависимости от времени года
data['Month'] = data['Date'].dt.month
seasonal_sales = data.groupby('Month')['Sales'].mean()

plt.figure(figsize=(10, 6))
seasonal_sales.plot(kind='line')
plt.title('Продажи по месяцам')
plt.xlabel('Месяц')
plt.ylabel('Средние продажи')
plt.show()

Этот код сначала загружает данные из CSV-файла, затем группирует их по магазинам и по месяцам, чтобы вычислить средние продажи. Далее он использует matplotlib и seaborn для визуализации результатов. Это дает наглядное представление о производительности каждого магазина и сезонных тенденциях в продажах.

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