TensorFlow – это библиотека программного обеспечения с открытым исходным кодом, созданная Google, которая используется для внедрения систем машинного обучения и глубокого обучения. Эти два имени содержат ряд мощных алгоритмов, которые разделяют общую задачу – позволить компьютеру узнать, как автоматически определять сложные шаблоны и / или принимать наилучшие возможные решения. TensorFlow, в основе своей, является библиотекой для программирования потока данных. Он использует различные методы оптимизации, чтобы сделать вычисления математических выражений проще и эффективнее.

В TensorFlow константы создаются с использованием функции: constant(value, dtype=None, shape=None, name=’Const’, verify_shape=False), где value постоянное значение, которое будет использоваться при дальнейших вычислениях, dtype является параметром, указывающим тип данных (например, float32/64, int8/16), shape является необязательным параметром, указывающим размер массива данных, name является необязательным задающим имя для тензора. Если вам нужны константы с определенными значениями внутри вашей обучающей модели, тогда объект типа constant может использоваться как в следующем примере: z = tf.constant(5.2, name=”x”, dtype=tf.float32).

Для создания сверточной нейронной сети была выбрана платформа Google Colab. Она обладает рядом преимуществ, а именно универсальна, является бесплатной платформой, представляет мощные технологии обработки данных и машинного обучения.

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

Решение задачи классификации изображений с помощью сверточных нейронных сетей осуществляет Google Colab — это бесплатный облачный сервис на основе Jupyter Notebook, он предоставляет всё необходимое для машинного обучения прямо в браузере, предоставляет бесплатный доступ.

Google Colab – блокнот для программирования на языке Python. В нем есть возможность для работы с серьезными технологиями при разработке реальных приложений data science и ML, предоставляет все необходимое для решения задач по анализу и обработке данных (с применимостью к Python).

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

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

– достаточность — число обучающих примеров должно быть достаточным для обучения;

– разнообразие;

– равномерность представления классов.

Датасеты – это то, на чем основывается наука о данных, материал, на котором основаны все исследования. В основном рассматривают два типа данных: традиционные и большие (Big Data).

Традиционные данные (структурируются и хранятся в базах, которые управляются с одного компьютера, данные представлены в виде таблиц, содержащих текст или числа).

Большие данные (массивнее, чем традиционные, основываются как на разнообразии (числа, текст, изображения, аудио, видео и т. д.), так и скорости извлечения и вычисления в реальном времени, и объема.)

Датасеты разделяются на три категории:

1. Простая запись – это самая простая форма, не имеющая явной связи между строками-наблюдениями или столбцами-признаками (каждая строка имеет одинаковый набор характеристик).

2. Графы (отношения между объектами фиксируются связями).

3. Упорядоченные записи (некоторые данные упорядочены во времени или пространстве).

Разработка моделей нейронной сети выполняется в облачном сервисе Google Colab. На первом этапе создается папка, в которой будет находится датасет и скрипт с нейронной сетью.

Работа над нейронной сетью начинается с добавления библиотек Tensorflow. Загружаем нужные библиотеки:

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Dense, Flatten

import pandas as pd

import numpy as np

import matplotlib.pyplot as plt

Так как нейронная сеть создается на сервисе Google Colab, датасет находится на Google диске, необходимо подключить диск к сети.

from google.colab import drive

drive.mount(‘/content/drive/’)

В случае успешного подключения к диску появляется всплывающее окно, говорящее об успешном подключении к нему.

Drive mounted at /content/drive/; to attempt to forcibly remount, call drive.mount(“/content/drive/”, force_remount=True).

Переменная PATH показывает путь сети к ранее созданному датасету.

PATH = ‘/content/drive/My Drive/II/nf/’

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

target_name = ["✖","✚","<",">","±","•","–","="]

DIR = “dataset_ _mathdeystvo ”

PATH = ‘/content/drive/My Drive/’+ DIR + ‘/’

PATH – корневой каталог для всех имеющихся на диске датасетов.

Переменные train_dir, test_dir, pred_dir – это пути, которые указывают на каталоги с данными для: обучения, тестирования, предсказания.

Следующим шагом указываем размер изображения. Тензоры можно рассматривать как матрицы, с формами. В Keras сам входной слой – это не слой, а тензор. Это стартовый тензор, который отправляется на первый скрытый слой. Этот тензор должен иметь ту же форму, что и тренировочные данные. Размер изображений в датасете составляет 20*20. Более удобно вводить переменную input_shape, которая в себе содержит сразу размерность изображений и количество фильтров.

В данной сети фильтр 1, так как используемые изображения в черно-белом цвете. Указываем размер мини-выборки с помощью переменной batch_size, которая отображает количество изображений, которые изучает модель за один проход. Нейронная сеть работает с данными постепенно, обработка происходит последовательно (частями).

# Размеры изображения

img_width, img_height = 20, 20

input_shape = (img_width, img_height, 1)

# Размер мини-выборки

batch_size = 128

# количество классификации

N = len(classes)

Загружаем данные для обучения с помощью метода pd.read_csv:

train = pd.read_csv(PATH + ‘train.csv’, sep=”,”) #, nrows=3975

Загружаем данные для тестирования:

val = pd.read_csv(PATH + ‘validate.csv’)

Исследуем данные. Просматриваем данные для обучения:

train[:5]

Выбираем 8 видов изображений (знак умножения, знак сложения, знак больше, знак меньше, знак плюс-минус, точка, знак минус, знак равно). Посмотрим на тренировочные данные:

plt.figure(figsize=(10,10))

start = 0

for i in range(start,start+50):

plt.subplot(5,10,i-start+1)

plt.xticks([])

plt.yticks([])

plt.grid(False)

plt.imshow(x_train[i].reshape((img_width, img_height)), cmap=plt.cm.binary)

plt.xlabel(classes[y_train[i]])

Был собран датасет в количестве нескольки тысяч изображений в черно-белом цвете (рисунок 6), так как для отработки нейронной сети необходимо большое количество изображений (при малых объемах датасета сеть свою работу не выполняет).

Рисунок 1. Датасет

Работа нейронной сети рассматривается в трех моделях.

1.    Двухслойная нейронная сеть.

Рассматривается сеть из двух нейронных слоев. Для создания модели используется класс Sequential. На входном слое находятся 1000 нейронов. Функция активации (запуска) relu, размер входных данных = 1024. На последнем слое должно быть 4 нейрона, так как это количество должно совпадать с количеством классификаций изображений (треугольник, квадрат, окружность, ромб).

Активация последнего слоя выполняется с помощью функции softmax.

Рисунок 2. Характеристики двухслойной модели

Рисунок 3. Предсказание нейронной сети

С помощью функции summary просматриваются все характеристики полученной трехслойной модели (рисунок 5).

Рисунок 4. Характеристики трехслойной модели

Полносвязная нейронная сеть недостаточно качественно выполняет работу с изображениями. Прогресс обучения двуслойной нейронной сети (78 %) и трехслойной нейронной сети (79 %) растет достаточно медленно, за счет увеличения количества слоев. Более качественный результат можно получить лишь, построив сверточную нейронную сеть.

Рисунок 5. Характеристики сверточной нейронной сети

Для распознавания дальнейших изображений используется метод predict, который позволяет распознавать, а далее выводить распознанные и истинные объекты. Подготовим в Paint собственные изображения и загрузим их на гугл-диск (рисунок 6)

Рисунок 6. Собственные изображения для проверки работы нейронной сети

По итогам распознавания собственных изображений можно сделать следующий вывод (таблица 1):

Таблица 1. Качество распознавания собственных изображений

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

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

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

Введение: почему пользователи ненавидят регистрацию

Мы все были в такой ситуации: нашли интересный сервис, хотите попробовать, но перед вами форма регистрации с десятком полей. 67% пользователей покидают сайт при виде сложной формы регистрации. Что если есть способ обойти этот барьер?

Авторизация без регистрации — это инновационный подход, который меняет парадигму взаимодействия пользователя с системой. Давайте разберемся, как это работает и когда стоит применять.

Что такое авторизация без регистрации?

Основная концепция

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

Классический vs Современный подход

| Традиционная модель | Модель без регистрации |

Регистрация → Подтверждение → Авторизация | Получение доступа → Использование |

Требует активных действий | Пассивное получение доступа |

Высокий порог входа | Мгновенный доступ |

Техническая реализация: от теории к практике

Архитектура системы

“`sql

– Оптимизированная таблица пользователей

CREATE TABLE users (

id INT PRIMARY KEY AUTO_INCREMENT,

username VARCHAR(100) UNIQUE NOT NULL,

password_hash VARCHAR(255) NOT NULL,

user_type ENUM(‘guest’, ‘full’) DEFAULT ‘guest’,

created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,

last_login TIMESTAMP NULL,

expires_at TIMESTAMP NULL,

is_active BOOLEAN DEFAULT TRUE,

INDEX idx_username (username),

INDEX idx_expires (expires_at),

INDEX idx_user_type (user_type)

);

“`

 Генерация временных учетных записей
```php
<?php
class TemporaryUserGenerator {
    private $db;
    private $guest_lifetime = '7 DAYS'; // Срок жизни гостевого аккаунта
    
    public function __construct(PDO $db) {
        $this->db = $db;
    }
    
    public function generateGuestUser(): array {
        // Генерация уникательного идентификатора
        $username = $this->generateUniqueUsername();
        $plain_password = $this->generateStrongPassword();
        
        // Хеширование пароля
        $password_hash = password_hash($plain_password, PASSWORD_DEFAULT);
        
        // Расчет даты истечения
        $expires_at = date('Y-m-d H:i:s', 
            strtotime("+{$this->guest_lifetime}"));
        
        try {
            $stmt = $this->db->prepare(
                "INSERT INTO users (username, password_hash, user_type, expires_at) 
                 VALUES (?, ?, 'guest', ?)"
            );
            
            $stmt->execute([$username, $password_hash, $expires_at]);
            
            return [
                'success' => true,
                'user_id' => $this->db->lastInsertId(),
                'username' => $username,
                'password' => $plain_password,
                'expires_at' => $expires_at
            ];
            
        } catch (PDOException $e) {
            error_log("Error creating guest user: " . $e->getMessage());
            return ['success' => false, 'error' => 'User creation failed'];
        }
    }
    
    private function generateUniqueUsername(): string {
        $prefix = "guest";
        $timestamp = time();
        $random = bin2hex(random_bytes(4));
        return "{$prefix}_{$timestamp}_{$random}";
    }
    
    private function generateStrongPassword(): string {
        $length = 12;
        $chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*';
        return substr(str_shuffle($chars), 0, $length);
    }
}
```
```
 Умная форма авторизации с гостевым доступом
```html
<!DOCTYPE html>
<html lang="ru">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Быстрый доступ к системе</title>
    <style>
        .auth-container {
            max-width: 400px;
            margin: 50px auto;
            padding: 30px;
            border: 1px solid #ddd;
            border-radius: 10px;
            box-shadow: 0 2px 10px rgba(0,0,0,0.1);
        }
        
        .form-group {
            margin-bottom: 20px;
        }
        
        .form-group label {
            display: block;
            margin-bottom: 5px;
            font-weight: bold;
        }
        
        .form-group input {
            width: 100%;
            padding: 10px;
            border: 1px solid #ccc;
            border-radius: 5px;
            box-sizing: border-box;
        }
        
        .btn {
            padding: 12px 24px;
            border: none;
            border-radius: 5px;
            cursor: pointer;
            font-size: 16px;
            transition: background-color 0.3s;
        }
        
        .btn-primary {
            background-color: #007bff;
            color: white;
        }
        
        .btn-primary:hover {
            background-color: #0056b3;
        }
        
        .btn-secondary {
            background-color: #6c757d;
            color: white;
            margin-left: 10px;
        }
        
        .btn-secondary:hover {
            background-color: #545b62;
        }
        
        .guest-access {
            margin-top: 30px;
            padding-top: 20px;
            border-top: 1px solid #eee;
            text-align: center;
        }
    </style>
</head>
<body>
    <div class="auth-container">
        <h2>Вход в систему</h2>
        
        <!-- Традиционная форма авторизации -->
        <form id="loginForm" action="login_handler.php" method="POST">
            <div class="form-group">
                <label for="username">Логин:</label>
                <input type="text" id="username" name="username" required>
            </div>
            
            <div class="form-group">
                <label for="password">Пароль:</label>
                <input type="password" id="password" name="password" required>
            </div>
            
            <button type="submit" class="btn btn-primary">Войти</button>
        </form>
        
        <!-- Гостевой доступ -->
        <div class="guest-access">
            <h3>Нет аккаунта?</h3>
            <p>Получите мгновенный гостевой доступ</p>
            <button onclick="getGuestAccess()" class="btn btn-secondary">
                Попробовать как гость
            </button>
        </div>
    </div>

    <script>
    async function getGuestAccess() {
        try {
            const response = await fetch('get_guest_access.php', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                }
            });
            
            const result = await response.json();
            
            if (result.success) {
                // Автоматический вход с полученными данными
                autoLogin(result.username, result.password);
            } else {
                alert('Ошибка получения доступа: ' + result.error);
            }
        } catch (error) {
            console.error('Error:', error);
            alert('Произошла ошибка при получении доступа');
        }
    }
    
    function autoLogin(username, password) {
        document.getElementById('username').value = username;
        document.getElementById('password').value = password;
        document.getElementById('loginForm').submit();
    }
    </script>
</body>
</html>
```
Безопасность: главный вызов
 Потенциальные риски
1. **Слабые пароли** - автоматическая генерация может создавать уязвимости
2. **Неограниченное создание аккаунтов** - риск DDoS-атак
3. **Анонимность** - сложность отслеживания злоумышленников
 Меры защиты
```php
<?php
class SecurityManager {
    private $db;
    
    public function __construct(PDO $db) {
        $this->db = $db;
    }
    
    // Ограничение создания аккаунтов с одного IP
    public function checkRateLimit(string $ip): bool {
        $stmt = $this->db->prepare(
            "SELECT COUNT(*) as count FROM user_creation_log 
             WHERE ip_address = ? AND created_at > DATE_SUB(NOW(), INTERVAL 1 HOUR)"
        );
        $stmt->execute([$ip]);
        $result = $stmt->fetch(PDO::FETCH_ASSOC);
        
        return $result['count'] < 10; // Максимум 10 аккаунтов в час
    }
    
    // Валидация сложности пароля
    public function validatePasswordStrength(string $password): bool {
        $min_length = 8;
        $has_uppercase = preg_match('/[A-Z]/', $password);
        $has_lowercase = preg_match('/[a-z]/', $password);
        $has_numbers = preg_match('/[0-9]/', $password);
        $has_special = preg_match('/[!@#$%^&*(),.?":{}|<>]/', $password);
        
        return strlen($password) >= $min_length 
            && $has_uppercase 
            && $has_lowercase 
            && $has_numbers 
            && $has_special;
    }
    // Очистка просроченных аккаунтов
    public function cleanupExpiredAccounts(): int {
        $stmt = $this->db->prepare(
            "DELETE FROM users 
             WHERE user_type = 'guest' 
             AND expires_at < NOW() 
             AND last_login IS NULL"
        );
        $stmt->execute();
        
        return $stmt->rowCount();
    }
}
```

Реальные кейсы применения

1. Демо-версии SaaS продуктов

**Проблема:** Пользователи хотят протестировать функционал перед покупкой

**Решение:** Гостевой доступ с ограниченным временем действия

2. Образовательные платформы

**Проблема:** Студенты не хотят регистрироваться для разового занятия

**Решение:** Временные коды доступа для участников мероприятия

3. Корпоративные порталы

**Проблема:** Внешние консультанты нуждаются во временном доступе

**Решение:** Пригласительные ссылки с автоматическим созданием аккаунта

## Преимущества и недостатки

Преимущества

Для пользователя:

- Мгновенный доступ к сервису

- Отсутствие барьеров входа

- Сохранение анонимности при необходимости

Для бизнеса:

- Увеличение конверсии посетителей в пользователей

- Снижение bounce rate

- Упрощение процесса онбординга

Недостатки:

Технические:

- Сложность управления временными аккаунтами

- Потенциальные проблемы с безопасностью

- Нагрузка на базу данных

Бизнес-риски:

- Сложность коммуникации с пользователями

- Ограничения персонализации

- Возможность злоупотреблений

Заключение

Авторизация без регистрации — это мощный инструмент, который может значительно улучшить пользовательский опыт, но требует тщательной проработки вопросов безопасности.

Ключевые выводы:

- Идеально подходит для сервисов, где важна скорость первого контакта

- Требует продуманной системы безопасности и мониторинга

- Должна сочетаться с механизмами постепенной регистрации

- Эффективность зависит от конкретного use case

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

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

Результаты исследований.

1. Спортивный туризм зародился в конце XIX века и получил широкую поддержку в XX веке, особенно в СССР, где была создана сеть туристских клубов и секций.
2. Современный спортивный туризм включает разнообразные направления, такие как горный, водный, пешеходный, велосипедный и спелеотуризм, каждое из которых предъявляет свои требования к участникам.
3. Спортивный туризм позитивно влияет на физическое и психическое здоровье, улучшая выносливость, мышечную силу, снижая стресс и повышая уверенность в себе.
4. Для безопасного и экологически ответственного участия в спортивном туризме необходимо соблюдать правила безопасности, использовать качественное снаряжение и минимизировать негативное воздействие на природу.

Введение

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

История развития спортивного туризма

Исторически спортивный туризм зародился в конце XIX века, когда люди начали активно исследовать горные районы Европы и Америки. Одним из первых примеров является восхождение на Монблан в Альпах в 1786 году, которое считается началом альпинизма как вида спорта. С тех пор популярность горных походов, скалолазания и других видов активного отдыха стремительно росла. В XX веке развитие технологий позволило создать специализированное снаряжение и оборудование, что значительно расширило возможности для занятий спортивным туризмом.

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

Основные виды спортивного туризма

Современный спортивный туризм включает множество различных направлений:

1. Горный туризм – включает пешие походы по горам, восхождения на вершины, прохождение перевалов и ледников. Горный туризм требует хорошей физической подготовки и специальных навыков.
2. Водный туризм – охватывает такие виды активности, как рафтинг, каякинг, сплав на байдарках и катамаранах. Водный туризм может проходить как по рекам с бурными порогами, так и по спокойным водоемам.
3. Пешеходный туризм – подразумевает длительные пешие маршруты по природным территориям, часто с ночевками в палатках. Пешеходный туризм доступен людям разного уровня подготовки.
4. Велосипедный туризм – предполагает путешествия на велосипеде по различным маршрутам, от лесных троп до горных дорог. Он может быть как самостоятельным видом активности, так и частью комбинированных туров, включающих другие виды транспорта.
5. Спелеотуризм – заключается в исследовании пещер и подземных ходов. Спелеотуризм требует специальной подготовки и оборудования, так как условия в пещерах могут быть экстремальными.

Влияние спортивного туризма на здоровье и психику

Занятия спортивным туризмом укрепляют сердечно-сосудистую систему, повышают выносливость и мышечную силу, снижают стресс и улучшают настроение. Участие в спортивных турах развивает уверенность в себе, ответственность и навыки работы в команде.

Однако следует помнить о возможных рисках, связанных с занятиями спортивным туризмом. Неправильная подготовка или недостаточная физическая форма могут привести к травмам и другим неприятностям.

Проблемы безопасности и экологии

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

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

Введение

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

Инструментарий

В качестве инструментария для решения поставленной задачи была выбрана библиотека TensorFlow с высокоуровневым фреймворком Keras, которые предоставляют удобные средства для создания и обучения нейронных сетей различной архитектуры. Для работы с табличными данными используется библиотека Pandas, для математических операций и работы с массивами – NumPy, для визуализации результатов – Matplotlib.

Загрузка данных

Поскольку работа выполнялась в среде Google Colab, потребовалось подключение Google Drive для доступа к файлам датасета:

from google.colab import drive

drive.mount(‘/content/drive/’)

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

DIR = “Titanic”

PATH = ‘/content/drive/My Drive/’+ DIR + ‘/’

train = pd.read_csv(PATH + ‘train.csv’)

test = pd.read_csv(PATH + ‘test.csv’)

sample_submission = pd.read_csv(PATH + ‘sample_submission.csv’, index_col=’PassengerId’)

Предобработка данных

Одной из важнейших задач при работе с реальными данными является их предобработка. Исходные данные содержат как числовые, так и категориальные признаки, которые необходимо преобразовать в формат, пригодный для обучения нейронной сети.

Замена категориальных признаков

В первую очередь производится замена текстовых значений пола на числовые:

train = train.replace(‘male’, 1).replace(‘female’, 0)

test = test.replace(‘male’, 1).replace(‘female’, 0)

Создание дамми-переменных

Далее создаются дамми-переменные для категориальных признаков Embarked (порт посадки) и Pclass (класс билета), что позволяет представить эти признаки в виде бинарных векторов:

train = pd.concat([train, pd.get_dummies(train.Embarked, prefix="Emb")], axis=1)

train = pd.concat([train, pd.get_dummies(train.Pclass, prefix="Pclass")], axis=1)

test = pd.concat([test, pd.get_dummies(test.Embarked, prefix="Emb")], axis=1)

test = pd.concat([test, pd.get_dummies(test.Pclass, prefix="Pclass")], axis=1)

Создание новых признаков

Важным этапом инженерного анализа данных является создание новых признаков, которые могут нести дополнительную информацию для модели. На основе имеющихся признаков Parch (количество родителей и детей) и SibSp (количество братьев, сестер, супругов) был создан новый бинарный признак “наличие более одного родственника”, принимающий значение 1, если у пассажира было более одного родственника на борту, и 0 в противном случае.

train['more than one relative'] = train.Parch + train.SibSp > 1

train = train.replace(True, 1).replace(False, 0)

test['more than one relative'] = test.Parch + test.SibSp > 1

test = test.replace(True, 1).replace(False, 0)

Анализ пропущенных значений

Производится анализ пропущенных значений с помощью методов isnull().sum():

train.isnull().sum()

Для визуализации используется тепловая карта библиотеки Seaborn, что позволяет наглядно увидеть, в каких колонках присутствуют пропуски:

import seaborn as sns

sns.heatmap(train.isnull(), cbar = False).set_title(“Карта пропущенных значений”)

Заполнение пропусков

На основе анализа принимается решение о заполнении пропущенных значений. Для числовых колонок Age и Fare пропуски заменяются средними значениями:

numeric_cols = ['Age', 'Fare']

train[numeric_cols] = train[numeric_cols].fillna(train[numeric_cols].mean())

test[numeric_cols] = test[numeric_cols].fillna(train[numeric_cols].mean())

При этом важно отметить, что для заполнения пропусков в тестовом наборе используются средние значения, вычисленные на тренировочном наборе, чтобы избежать утечки данных.

Формирование признакового пространства

После завершения предобработки формируется список признаков features и целевая переменная target:

features = ['Pclass_1', 'Pclass_2', 'Pclass_3', 'Age', 'Sex', 'Fare', 'more than one relative', 'Emb_C', 'Emb_Q', 'Emb_S']

target = ‘Survived’

Данные преобразуются в массивы NumPy для подачи в нейронную сеть:

X_train = train[features].values

Y_train = train[target].values

X_test = test[features].values

Нормализация данных

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

mean = X_train.mean(axis=0)

std = X_train.std(axis=0)

X_train = X_train – mean

X_train /= std

X_test = X_test – mean

X_test /= std

Построение модели нейронной сети

Для построения модели используется последовательная архитектура Sequential с импортом необходимых слоев:

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Dense, Dropout

Модель состоит из трех полносвязных слоев. Первый слой содержит 200 нейронов с функцией активации ReLU и принимает на вход данные размерности, соответствующей количеству признаков. Второй скрытый слой содержит 20 нейронов также с функцией активации ReLU. Выходной слой содержит один нейрон с сигмоидной функцией активации, что позволяет получать на выходе вероятность принадлежности к классу 1 (выживший) в диапазоне от 0 до 1.

Для предотвращения переобучения после каждого скрытого слоя добавляется слой Dropout с вероятностью отключения нейронов 0.1:

model = Sequential()

model.add(Dense(200, activation=’relu’, input_shape=(X_train.shape[1],)))

model.add(Dropout(0.1))

model.add(Dense(20, activation=’relu’))

model.add(Dropout(0.1))

model.add(Dense(1, activation=’sigmoid’))

После создания модели выводится ее краткое описание:

print(model.summary())

Компиляция модели

Компиляция модели производится с использованием оптимизатора Adam. В качестве функции потерь используется binary_crossentropy, подходящая для бинарной классификации. Метрикой качества выбрана accuracy – доля правильных ответов:

model.compile(optimizer=’adam’, loss=’binary_crossentropy’, metrics=['accuracy'])

Обучение модели

Обучение модели производится на тренировочных данных с валидационным разделением 10% от обучающей выборки. Количество эпох обучения установлено равным 2, размер пакета batch_size равен 1:

history = model.fit(X_train, Y_train,

                    epochs=2,

                    batch_size=1,

                    validation_split=0.1,

                    verbose=2)

Визуализация процесса обучения

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

plt.plot(history.history['accuracy'], label=’Точность на обучающем наборе’)

plt.plot(history.history['val_accuracy'], label=’Точность на проверочном наборе’)

plt.xlabel(‘Эпоха обучения’)

plt.ylabel(‘Точность’)

plt.legend()

plt.show()

График позволяет оценить, насколько хорошо модель обучается, и демонстрирует рост точности в процессе обучения.

Предсказание на тестовых данных

После завершения обучения производится предсказание на тестовых данных:

predictions = model.predict(X_test)

Полученные предсказания представляют собой вероятности принадлежности к классу 1. Для преобразования вероятностей в бинарные метки используется пороговое значение 0.5:

sample_submission[target] = [0 if pred < 0.5 else 1 for pred in predictions]

Экспорт результатов

Полученные предсказания записываются в файл-образец и сохраняются в файл titanic_submission.csv:

sample_submission.to_csv(‘titanic_submission.csv’)

Поскольку работа велась в Google Colab, для загрузки файла на локальный компьютер используется модуль files:

from google.colab import files

files.download(‘titanic_submission.csv’)

Заключение

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

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

WebGL – это программная библиотека для JavaScript, которая позволяет создавать 3D графику, функционирующую в браузерах. Данная библиотека основана на архитектуре OpenGL. WebGL использует язык программирования шейдеров GLSL, имеющий C-подобный синтаксис. Особенность WebGL заключается в том, что код моделируется непосредственно в браузере с использованием элемента canvas, введенного в HTML5.

Работа с WebGL и шейдерами в частности — довольно трудоемкий процесс, требующий описания каждой точки, линии и грани. Для визуализации необходимо прописывать объемные фрагменты кода. Чтобы ускорить разработку, была создана библиотека Three.js, которая представляет собой набор готовых классов для создания и отображения интерактивной 3D графики. Three.js для WebGL — это как jQuery для JavaScript: библиотека предлагает декларативный синтаксис и абстрагирует разработчика от сложностей, связанных с 3D в браузере.

Для создания сцены с геометрическими фигурами мы использовали современный подход с импортом модулей:

javascript

import * as THREE from ‘three’;

import { OrbitControls } from ‘three/addons/controls/OrbitControls.js’;

Такой способ подключения (с использованием import maps) является более чистым и предпочтительным в современных веб-приложениях.

Инициализация сцены и основных компонентов

Первым шагом мы создаем сцену, камеру и рендерер:

javascript

const container = document.createElement(‘div’);

document.body.appendChild(container);

camera = new THREE.PerspectiveCamera(45, window.innerWidth / window.innerHeight, 1, 5000);

camera.position.set(300, 500, 1200);

renderer = new THREE.WebGLRenderer({ antialias: true });

renderer.setSize(window.innerWidth, window.innerHeight);

container.appendChild(renderer.domElement);

Камера установлена на оптимальном расстоянии (1200 единиц), чтобы хорошо видеть оба ряда фигур. Параметр antialias включает сглаживание для более плавных краев объектов.

Освещение сцены

Для корректного отображения цветов и теней мы добавили два типа освещения:

javascript

ambientLight = new THREE.AmbientLight(0×404040, 2.0);

light = new THREE.DirectionalLight(0xffffff, 1.5);

light.position.set(1, 2, 1);

Фоновый свет (AmbientLight) обеспечивает базовое освещение всех поверхностей, а направленный свет (DirectionalLight) создает объем и подчеркивает форму объектов.

Управление камерой

Для интерактивного взаимодействия с пользователем подключены контроллеры OrbitControls, позволяющие вращать камеру вокруг сцены, приближать и отдалять изображение:

javascript

controls = new OrbitControls(camera, renderer.domElement);

controls.rotateSpeed = 0.5;

controls.enableZoom = true;

controls.minDistance = 300;

controls.maxDistance = 2000;

controls.enableDamping = true;

Размещение фигур в пространстве

Для организации фигур мы использовали Декартову систему координат и расположили объекты в два ряда. Каждая фигура имеет свои координаты position.set(x, y, z):

javascript

// Параметры расположения

const spacingX = 300;       // расстояние между фигурами по X

const startX = -450;        // начальная координата X

const row1Z = -200;         // координата Z для первого ряда (задний)

const row2Z = 200;          // координата Z для второго ряда (передний)

Создание геометрических фигур

В нашей сцене представлены различные типы геометрических тел, созданные с помощью встроенных классов Three.js:

1. Прямоугольник (BoxGeometry)

javascript

const geomBox = new THREE.BoxGeometry(300, 200, 220);

const box = new THREE.Mesh(geomBox, new THREE.MeshPhongMaterial({ color: 0xFFFF00 }));

2. Цилиндры и призмы (CylinderGeometry)

Класс CylinderGeometry универсален и позволяет создавать различные фигуры путем изменения параметров:

• Цилиндр (равные радиусы сверху и снизу, много сегментов)
• Треугольная призма (равные радиусы, 3 сегмента)
• Пятиугольная и шестиугольная призмы (равные радиусы, 5 и 6 сегментов)

3. Пирамиды и конусы

Установка верхнего радиуса в 0 превращает цилиндр в пирамиду или конус:

• Четырехугольная пирамида (верхний радиус 0, 4 сегмента)
• Шестиугольная пирамида (верхний радиус 0, 6 сегментов)
• Конус (верхний радиус 0, много сегментов для гладкости)

Цветовое оформление

Для каждой фигуры подобран индивидуальный цвет, делающий композицию яркой и наглядной:

• Желтый прямоугольник (0xFFFF00)
• Синий цилиндр (0x0000FF)
• Красная треугольная призма (0xFF0000)
• Зеленая шестиугольная пирамида (0x00FF00)
• Голубая пятиугольная призма (0x87CEEB)
• Салатовая четырехугольная пирамида (0x90EE90)
• Розовая шестиугольная призма (0xFFC0CB)
• Золотой конус (0xFFD700)

Визуализация и анимация

Для непрерывной отрисовки сцены используется цикл анимации:

javascript

function animate() {

    requestAnimationFrame(animate);

    controls.update();

    render();

}

function render() {

    renderer.render(scene, camera);

}

Обработчик изменения размера окна обеспечивает корректное масштабирование сцены:

javascript

window.addEventListener(‘resize’, onWindowResize, false);

Результат

В результате выполнения кода мы получаем интерактивную 3D-сцену с двумя рядами геометрических фигур (всего 8 объектов), расположенных на сером фоне со вспомогательной сеткой. Пользователь может свободно вращать камеру, приближать и рассматривать каждую фигуру с разных ракурсов, что делает данное решение отличным демонстрационным материалом для изучения возможностей Three.js и WebGL.

Введение

В современном мире мобильные приложения стали неотъемлемой частью повседневной жизни человека. Одним из ключевых аспектов успешного приложения является удобство его использования, включая интуитивно понятные элементы ввода данных. Функция автозаполнения позволяет значительно ускорить процесс ввода информации и снизить количество ошибок со стороны пользователя. В операционной системе Android для реализации данной функции предусмотрен специальный элемент интерфейса – AutoCompleteTextView, который представляет собой расширение обычного текстового поля EditText с возможностью отображения выпадающего списка подсказок.

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

Инструментарий и среда разработки

Для разработки приложения использовалась среда Android Studio – официальная интегрированная среда разработки для платформы Android. Приложение написано на языке Java с использованием Android SDK. В качестве целевой платформы выбрана актуальная версия Android с поддержкой библиотеки AndroidX, обеспечивающей обратную совместимость приложения с более ранними версиями операционной системы.

Структура проекта

Проект состоит из двух основных файлов:

• MainActivity.java – главный класс активности, содержащий логику работы приложения
• activity_main.xml – файл разметки, определяющий пользовательский интерфейс

Разработка пользовательского интерфейса

Пользовательский интерфейс приложения создается с использованием декларативного подхода в XML-файле разметки. Корневым элементом выступает ConstraintLayout, который обеспечивает гибкое позиционирование дочерних элементов. Внутри него размещается LinearLayout с вертикальной ориентацией, центрирующий содержимое на экране:

<androidx.constraintlayout.widget.ConstraintLayout

    xmlns:android=”http://schemas.android.com/apk/res/android”

    xmlns:app=”http://schemas.android.com/apk/res-auto”

    android:id=”@+id/main”

    android:layout_width=”match_parent”

    android:layout_height=”match_parent”>

    <LinearLayout

        android:layout_width=”match_parent”

        android:layout_height=”match_parent”

        android:orientation=”vertical”

        android:gravity=”center”

        android:padding=”24dp”

        app:layout_constraintBottom_toBottomOf=”parent”

        app:layout_constraintEnd_toEndOf=”parent”

        app:layout_constraintStart_toStartOf=”parent”

        app:layout_constraintTop_toTopOf=”parent”>

Интерфейс содержит два основных элемента. Заголовок приложения реализован с помощью TextView с текстом “Косметика”, увеличенным размером шрифта 24sp и полужирным начертанием:

<TextView

    android:layout_width=”wrap_content”

    android:layout_height=”wrap_content”

    android:text=”Косметика”

    android:textSize=”24sp”

    android:textStyle=”bold”

    android:layout_marginBottom=”32dp” />

Основной элемент – AutoCompleteTextView с идентификатором autoCompleteTextView2. Ему заданы параметры ширины на весь родительский контейнер, отступы для удобства касания, фон в виде стандартной рамки для редактирования и порог срабатывания автозаполнения, равный одному символу:

<AutoCompleteTextView

    android:id=”@+id/autoCompleteTextView2″

    android:layout_width=”match_parent”

    android:layout_height=”wrap_content”

    android:hint=”Введите название косметики”

    android:inputType=”text”

    android:padding=”12dp”

    android:background=”@android:drawable/editbox_background”

    android:completionThreshold=”1″ />

Реализация логики приложения

Логика приложения реализована в классе MainActivity, наследующемся от AppCompatActivity. Вначале объявляется массив строк с названиями косметических продуктов, которые будут служить источником данных для автозаполнения:

public class MainActivity extends AppCompatActivity {

    String[] seaFish = {

        “Мицеллярная вода”,

        “Тоник для лица”,

        “Сыворотка с гиалуроновой кислотой”,

        “Крем для век”,

        “Пилинг-скатка”,

        “Тональный крем”,

        “Консилер”,

        “Тушь для ресниц”,

        “Матовая помада”,

        “Скраб для тела”,

        “Масло для волос”,

        “Шампунь для объёма”,

        “Парфюмированная вода”

    };

}

Метод onCreate является точкой входа в активность. В нем производится инициализация интерфейса с помощью setContentView, подключение режима EdgeToEdge для использования всей площади экрана и настройка отступов для системных панелей:

@Override

protected void onCreate(Bundle savedInstanceState) {

    super.onCreate(savedInstanceState);

    EdgeToEdge.enable(this);

    setContentView(R.layout.activity_main);

    ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main), (v, insets) -> {

        Insets systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars());

        v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom);

        return insets;

    });

}

Настройка AutoCompleteTextView

Ключевым моментом в разработке является правильная настройка элемента автозаполнения. Сначала производится поиск элемента по его идентификатору:

AutoCompleteTextView autoCompleteTextView = findViewById(R.id.autoCompleteTextView2);

Важно отметить, что в исходном коде используется идентификатор autoCompleteTextView2, который должен соответствовать идентификатору, указанному в XML-разметке. Это обеспечивает связь между логикой приложения и пользовательским интерфейсом.

Далее создается адаптер массива ArrayAdapter, который связывает данные (массив строк с названиями косметики) с элементом интерфейса. В качестве макета для отображения элементов выпадающего списка используется стандартный системный макет simple_dropdown_item_1line:

ArrayAdapter<String> adapter = new ArrayAdapter<>(

    this,

    android.R.layout.simple_dropdown_item_1line,

    seaFish

);

После создания адаптера он устанавливается для AutoCompleteTextView с помощью метода setAdapter. Метод setThreshold(1) определяет минимальное количество символов, которое должен ввести пользователь для появления подсказок. Значение 1 означает, что выпадающий список будет появляться после ввода первого же символа:

autoCompleteTextView.setAdapter(adapter);

autoCompleteTextView.setThreshold(1);

autoCompleteTextView.setHint(“Введите название косметики”);

autoCompleteTextView.setText(“”);

Обработка ошибок и проверка наличия элемента

В коде предусмотрена проверка на null для элемента AutoCompleteTextView. Это делается для предотвращения возможных ошибок, если по какой-то причине элемент с указанным идентификатором не будет найден в разметке:

if (autoCompleteTextView != null) {

    // настройка адаптера и параметров

}

Принцип работы приложения

При запуске приложения пользователь видит экран с заголовком “Косметика” и полем ввода с подсказкой “Введите название косметики”. Когда пользователь начинает вводить текст, система автоматически фильтрует массив данных и отображает выпадающий список с подходящими вариантами. При выборе одного из вариантов текст автоматически подставляется в поле ввода.

Механизм автозаполнения работает следующим образом: при каждом изменении текста в поле ввода AutoCompleteTextView передает введенный фрагмент адаптеру, который, в свою очередь, фильтрует массив данных, оставляя только те элементы, которые содержат введенную подстроку. Отфильтрованный список отображается в выпадающем окне.

Особенности реализации

В процессе разработки были учтены следующие важные моменты:

1. Использование AndroidX – библиотека обеспечивает совместимость с различными версиями Android и предоставляет современные компоненты интерфейса.
2. EdgeToEdge – режим позволяет приложению использовать всю область экрана, включая области под системными панелями.
3. Обработка отступов – правильная настройка отступов гарантирует, что содержимое не будет перекрыто системными элементами (строка состояния, навигационная панель).
4. Проверка наличия элемента – защита от возможных ошибок при поиске view по идентификатору.
5. Выбор макета для выпадающего списка – использование системного макета simple_dropdown_item_1line обеспечивает единообразный внешний вид с другими приложениями Android.

Результат работы

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

Интерфейс приложения интуитивно понятен и соответствует рекомендациям Material Design. Приложение корректно отображается на различных устройствах благодаря использованию ConstraintLayout и правильной обработке системных отступов.

Заключение

В ходе выполнения работы были изучены и практически применены следующие аспекты Android-разработки:

• создание пользовательского интерфейса с использованием XML-разметки;
• работа с элементом AutoCompleteTextView и его настройка;
• использование ArrayAdapter для связывания данных с элементами интерфейса;
• обработка системных отступов для корректного отображения на различных экранах;
• применение современных библиотек AndroidX.

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