В этом коде будет реализована функция, которая переводит текст на английском языке в код Морзе, и наоборот.

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

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

# Словарь для азбуки Морзе
MORSE_CODE_DICT = {
    'A': '.-', 'B': '-...', 'C': '-.-.', 'D': '-..', 'E': '.', 'F': '..-.', 
    'G': '--.', 'H': '....', 'I': '..', 'J': '.---', 'K': '-.-', 'L': '.-..', 
    'M': '--', 'N': '-.', 'O': '---', 'P': '.--.', 'Q': '--.-', 'R': '.-.', 
    'S': '...', 'T': '-', 'U': '..-', 'V': '...-', 'W': '.--', 'X': '-..-', 
    'Y': '-.--', 'Z': '--..', '1': '.----', '2': '..---', '3': '...--', 
    '4': '....-', '5': '.....', '6': '-....', '7': '--...', '8': '---..', 
    '9': '----.', '0': '-----', ', ': '--..--', '.': '.-.-.-', '?': '..--..', 
    '/': '-..-.', '-': '-....-', '(': '-.--.', ')': '-.--.-'
}

# Функция для перевода текста в азбуку Морзе
def text_to_morse(text):
    morse_code = ''
    for char in text.upper():
        if char in MORSE_CODE_DICT:
            morse_code += MORSE_CODE_DICT[char] + ' '
        elif char == ' ':
            morse_code += ' '
    return morse_code.strip()

# Функция для перевода азбуки Морзе в текст
def morse_to_text(morse_code):
    text = ''
    morse_code += ' '
    morse_char = ''
    for char in morse_code:
        if char != ' ':
            morse_char += char
            space_found = 0
        else:
            space_found += 1
            if space_found == 2 :
                text += ' '
            else:
                text += list(MORSE_CODE_DICT.keys())[list(MORSE_CODE_DICT.values()).index(morse_char)]
                morse_char = ''
    return text

# Тестирование функций
sample_text = "Hello World"
sample_morse = text_to_morse(sample_text)
reverted_text = morse_to_text(sample_morse)

sample_text, sample_morse, reverted_text

Пример работы кода:

('Hello World', '.... . .-.. .-.. ---  .-- --- .-. .-.. -..', 'HELLO WORLD')

- Исходный текст: "Hello World"
- Текст, переведённый в код Морзе: ".... . .-.. .-.. --- .-- --- .-. .-.. -.."
- Текст, восстановленный из кода Морзе: "HELLO WORLD"

Как видно, текст успешно переведён в азбуку Морзе и обратно. Обратите внимание, что возвращаемый текст написан заглавными буквами, так как в словаре азбуки Морзе используются только заглавные буквы.

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

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

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

Напишем этот код:

# Словарь для двоичного кода
BINARY_CODE_DICT = {
    'A': '01', 'B': '0001', 'C': '0010', 'D': '0011', 'E': '10', 
    'F': '0100', 'G': '0101', 'H': '0110', 'I': '0111', 'J': '1000', 
    'K': '1001', 'L': '1010', 'M': '1011', 'N': '1100', 'O': '1101', 
    'P': '1110', 'Q': '1111', 'R': '0000', 'S': '00000', 'T': '00001', 
    'U': '00010', 'V': '00011', 'W': '00100', 'X': '00101', 'Y': '00110', 
    'Z': '00111'
}

# Функция для перевода текста в двоичный код
def text_to_binary_code(text):
    binary_code = ''
    for char in text.upper():
        if char in BINARY_CODE_DICT:
            binary_code += BINARY_CODE_DICT[char] + ' '
        elif char == ' ':
            binary_code += '  '
    return binary_code.strip()

# Функция для перевода двоичного кода в текст
def binary_code_to_text(binary_code):
    text = ''
    binary_code += '  '  # Дополнительный пробел для обозначения конца строки
    binary_char = ''
    for char in binary_code:
        if char != ' ':
            binary_char += char
        else:
            if binary_char:
                if binary_char in BINARY_CODE_DICT.values():
                    text += list(BINARY_CODE_DICT.keys())[list(BINARY_CODE_DICT.values()).index(binary_char)]
                binary_char = ''
            else:
                text += ' '
    return text.strip()

# Тестирование функций
sample_text_binary = "Hello"
sample_binary = text_to_binary_code(sample_text_binary)
reverted_text_binary = binary_code_to_text(sample_binary)

sample_text_binary, sample_binary, reverted_text_binary

Пример работы кода для двоичной системы:

('Hello', '0110 10 1010 1010 1101', 'HELLO')

- Исходный текст: "Hello"
- Текст, переведённый в двоичный код: "0110 10 1010 1010 1101"
- Текст, восстановленный из двоичного кода: "HELLO"

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

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

Импульсные нейросети (SNNs, Spiking Neural Networks) — это класс нейросетей, который моделирует более реалистичное поведение нейронов, чем традиционные искусственные нейронные сети. В импульсных нейросетях нейроны обмениваются информацией не постоянными значениями активации, а короткими импульсами (спайками), что приближает их к работе биологических нейронных сетей.

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

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

from brian2 import *

# Параметры модели нейрона
tau = 10*ms
eqs = '''
dv/dt = (1-v)/tau : 1 (unless refractory)
'''

# Создание нейрона
G = NeuronGroup(1, eqs, threshold='v>0.8', reset='v = 0', refractory=5*ms, method='exact')

# Инициализация переменной состояния
G.v = 0

# Мониторинг переменных
state_monitor = StateMonitor(G, 'v', record=True)
spike_monitor = SpikeMonitor(G)

# Запуск симуляции
run(100*ms)

# Визуализация данных
figure(figsize=(12, 4))
subplot(121)
plot(state_monitor.t/ms, state_monitor.v[0])
xlabel('Time (ms)')
ylabel('v')
subplot(122)
plot(spike_monitor.t/ms, spike_monitor.i, 'ob')
xlabel('Time (ms)')
ylabel('Spikes')

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

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

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

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

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

from brian2 import *

# Параметры модели
num_neurons = 10
tau = 10*ms
equation = '''
dv/dt = (sin(2*pi*1*Hz*t)-v)/tau : 1 (unless refractory)
'''

# Создание двух групп нейронов
G1 = NeuronGroup(num_neurons, equation, threshold='v>0.5', reset='v = 0', refractory=5*ms)
G2 = NeuronGroup(num_neurons, equation, threshold='v>0.5', reset='v = 0', refractory=5*ms)

# Инициализация переменных
G1.v = 'rand()'
G2.v = 'rand()'

# Создание синапсов
S = Synapses(G1, G2, on_pre='v_post += 0.2')
S.connect(j='i')

# Мониторинг
M1 = StateMonitor(G1, 'v', record=True)
M2 = StateMonitor(G2, 'v', record=True)
spikemon = SpikeMonitor(G1)

# Запуск симуляции
run(100*ms)

# Визуализация
figure(figsize=(15, 5))
subplot(131)
plot(M1.t/ms, M1.v.T)
xlabel('Time (ms)')
ylabel('v')
title('Neurons in G1')
subplot(132)
plot(M2.t/ms, M2.v.T)
xlabel('Time (ms)')
title('Neurons in G2')
subplot(133)
plot(spikemon.t/ms, spikemon.i, '.k')
xlabel('Time (ms)')
ylabel('Neuron index')
title('Spikes in G1')
tight_layout()
show()

В этом коде мы создали две группы нейронов G1 и G2, каждая из которых содержит 10 нейронов. Нейроны в G1 связаны синапсами с нейронами в G2. Когда нейрон в G1 генерирует спайк, он увеличивает переменную состояния v связанных с ним нейронов в G2.

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

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

В Python существует несколько основных типов коллекций, включая списки (list), кортежи (tuple), множества (set) и словари (dict). Для демонстрации различий между этими типами коллекций, я напишу код, который иллюстрирует их основные характеристики и поведение.

1. Списки (List): Упорядоченная, изменяемая коллекция, которая позволяет хранить дубликаты.
2. Кортежи (Tuple): Упорядоченная, неизменяемая коллекция, которая также позволяет хранить дубликаты.
3. Множества (Set): Неупорядоченная коллекция без индексации, не позволяет хранить дубликаты и является изменяемой.
4. Словари (Dict): Коллекция пар ключ-значение, которая неупорядочена (до Python 3.7) и изменяема. Ключи должны быть уникальными.

Ниже приведен код, демонстрирующий особенности каждой из этих коллекций:

# Список (List)
my_list = [1, 2, 2, 3, 4]
print("List:", my_list)
my_list.append(5)
print("List after append:", my_list)

# Кортеж (Tuple)
my_tuple = (1, 2, 3, 3, 4)
print("\nTuple:", my_tuple)

# Множество (Set)
my_set = {1, 2, 2, 3, 4}
print("\nSet:", my_set)
my_set.add(5)
print("Set after add:", my_set)

# Словарь (Dict)
my_dict = {'a': 1, 'b': 2, 'c': 3}
print("\nDictionary:", my_dict)
my_dict['d'] = 4
print("Dictionary after adding a key-value pair:", my_dict)

# Демонстрация ключевых отличий
print("\nDemonstrating key differences:")
print("List allows duplicates:", my_list)
print("Tuple is immutable:", my_tuple)
print("Set does not allow duplicates and is unordered:", my_set)
print("Dictionary stores key-value pairs:", my_dict)

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

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

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

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

2. Использование с функциями высшего порядка: Функции, такие как map(), filter() и reduce(), часто используют лямбда-функции для выполнения операций с элементами коллекции.

3. Операции с данными: В обработке данных лямбда-функции полезны для применения простых преобразований к элементам.

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

# Пример 1: Сортировка списка кортежей по второму элементу
pairs = [(1, 'one'), (2, 'three'), (3, 'two')]
pairs.sort(key=lambda pair: pair[1])
print("Sorted by second element:", pairs)

# Пример 2: Использование с map(), filter(), и reduce()
numbers = [1, 2, 3, 4, 5]

# Удвоение каждого элемента
doubled = list(map(lambda x: x * 2, numbers))
print("Doubled numbers:", doubled)

# Фильтрация нечетных чисел
filtered = list(filter(lambda x: x % 2 == 0, numbers))
print("Filtered even numbers:", filtered)

# Суммирование всех элементов
from functools import reduce
summed = reduce(lambda a, b: a + b, numbers)
print("Sum of numbers:", summed)

# Пример 3: Преобразование элементов списка
names = ["Alice", "Bob", "Charlie"]
uppercase_names = list(map(lambda name: name.upper(), names))
print("Uppercase names:", uppercase_names)

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

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

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

Вот пример функции с docstring, которая рассчитывает квадратный корень числа:

def sqrt(number):
    """
    Вычисляет квадратный корень числа.

    Параметры:
    number (float): Число, для которого нужно найти квадратный корень. Должно быть неотрицательным.

    Возвращает:
    float: Квадратный корень из number.

    Вызывает ValueError, если number отрицательный.
    """
    if number < 0:
        raise ValueError("Нельзя вычислить квадратный корень из отрицательного числа")
    return number ** 0.5

# Пример использования функции
try:
    result = sqrt(9)
    print("Квадратный корень из 9 равен", result)
except ValueError as e:
    print(e)

В этом примере:

- **Docstring** начинается сразу после строки с def и описывает назначение функции, её параметры, возвращаемое значение и исключения, которые она может вызвать.
- Функция sqrt вычисляет квадратный корень числа. Если входное число отрицательное, она вызывает исключение ValueError.
- В конце кода есть пример использования функции sqrt.

Docstring является важным элементом в создании понятного и легко поддерживаемого кода, особенно в больших и сложных проектах.

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

Docstring — это основной инструмент в Python для создания документации кода непосредственно в исходных файлах. Это очень полезно для автоматической генерации документации, так как многие инструменты автодокументации, такие как Sphinx, могут напрямую использовать эту информацию. Вот как вы можете использовать docstring для автодокументации:

1. Соблюдение стандартов docstring: Существует несколько распространенных форматов docstring, таких как reStructuredText (reST), Google style, NumPy/SciPy style и другие. Выбор стандартного стиля облегчает использование инструментов, таких как Sphinx, для автоматической генерации документации.

2. Использование инструментов для генерации документации:
- Sphinx: Это мощный инструмент, который извлекает информацию из docstring и генерирует документацию в различных форматах, включая HTML, LaTeX (для печатных PDF) и другие. Sphinx поддерживает множество расширений и интегрируется с различными форматами docstring.
- pydoc: Утилита, входящая в стандартную библиотеку Python, которая может генерировать текстовую или HTML-документацию из docstring в вашем коде.

3. Написание информативных docstring:
- Опишите назначение функций, классов, методов и модулей.
- Укажите параметры, типы, возвращаемые значения и исключения.
- Приведите примеры использования, если это уместно.

4. Интеграция с системами контроля версий и CI/CD:
- Можно настроить Sphinx или другие инструменты для автоматической генерации и обновления документации при каждом коммите в систему контроля версий.
- Используйте платформы CI/CD, такие как Jenkins, Travis CI, или GitHub Actions, для автоматизации процесса генерации и публикации документации.

5. Поддержание актуальности документации:
- Регулярно обновляйте docstring в вашем коде, чтобы документация оставалась актуальной.
- Включите написание и обновление docstring в процесс разработки.

Пример использования Sphinx с docstring:

1. Установите Sphinx: pip install sphinx
2. Инициализируйте Sphinx в директории вашего проекта: sphinx-quickstart
3. Настройте conf.py в сгенерированной директории Sphinx, указав путь к вашему проекту и выбранный формат docstring.
4. Создайте .rst файлы (или используйте sphinx-apidoc для их автоматической генерации) для организации структуры документации.
5. Сгенерируйте документацию, запустив make html (или другую команду в зависимости от желаемого формата).

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

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

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

Давайте создадим простой симулятор, где "бактерии" размножаются в ограниченном пространстве. Бактерии будут размножаться (делиться на две части) каждый шаг симуляции с определенной вероятностью. Пространство для бактерий будет ограничено, так что когда оно заполнится, бактерии перестанут размножаться. Это модель может быть использована для демонстрации базового экспоненциального роста и ограничений ресурсов.

Начнем с написания кода:

import numpy as np
import matplotlib.pyplot as plt

# Настройки симуляции
size = 10  # Размер среды (size x size)
initial_population = 5  # Начальное количество бактерий
reproduction_prob = 0.2  # Вероятность размножения бактерии за шаг
max_steps = 50  # Максимальное количество шагов симуляции

# Инициализация среды
environment = np.zeros((size, size), dtype=int)

# Размещаем начальную популяцию бактерий
initial_positions = np.random.choice(size*size, initial_population, replace=False)
environment[np.unravel_index(initial_positions, (size, size))] = 1

# Функция для отображения среды
def plot_environment(env, step):
    plt.imshow(env, cmap='Greens')
    plt.title(f"Шаг {step}")
    plt.show()

# Симуляция
for step in range(1, max_steps + 1):
    # Находим координаты всех бактерий
    bacteria_coords = np.argwhere(environment == 1)
    
    for x, y in bacteria_coords:
        # Размножаем бактерии с заданной вероятностью
        if np.random.random() < reproduction_prob:
            # Выбираем случайное направление для размножения
            dx, dy = np.random.choice([-1, 0, 1]), np.random.choice([-1, 0, 1])
            new_x, new_y = (x + dx) % size, (y + dy) % size
            # Если клетка свободна, размещаем туда новую бактерию
            if environment[new_x, new_y] == 0:
                environment[new_x, new_y] = 1

    # Отображаем состояние среды после каждого шага
    plot_environment(environment, step)

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

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

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

В этой модели:
- Клетки будут представлены элементами на сетке.
- Вирусы будут заражать эти клетки.
- Зараженные клетки будут производить новые вирусы, которые могут заразить другие клетки.

import numpy as np
import matplotlib.pyplot as plt

# Настройки симуляции
size = 10  # Размер среды
initial_viruses = 3  # Начальное количество вирусов
infection_prob = 0.3  # Вероятность заражения клетки вирусом
reproduction_rate = 2  # Количество новых вирусов от одной зараженной клетки
max_steps = 30  # Максимальное количество шагов симуляции

# Инициализация среды
environment = np.zeros((size, size), dtype=int)

# Размещаем начальные вирусы
for _ in range(initial_viruses):
    x, y = np.random.randint(0, size, 2)
    environment[x, y] = 1

# Функция для отображения среды
def plot_environment(env, step):
    plt.imshow(env, cmap='coolwarm', alpha=0.8)
    plt.title(f"Шаг {step}")
    plt.show()

# Симуляция
for step in range(1, max_steps + 1):
    new_viruses = []
    for x in range(size):
        for y in range(size):
            if environment[x, y] == 0 and np.random.random() < infection_prob:
                environment[x, y] = 1
            elif environment[x, y] == 1:
                for _ in range(reproduction_rate):
                    dx, dy = np.random.choice([-1, 0, 1]), np.random.choice([-1, 0, 1])
                    new_x, new_y = (x + dx) % size, (y + dy) % size
                    new_viruses.append((new_x, new_y))
    for x, y in new_viruses:
        environment[x, y] = 1
    plot_environment(environment, step)

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

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

Quantitative Development (Quant Dev) в финансовом мире включает в себя разработку алгоритмов, моделей и инструментов для количественного анализа, часто используемых в алгоритмической торговле и риск-менеджменте. Ниже я представлю пример кода на Python, который иллюстрирует базовый подход к Quant Development. В этом примере мы создадим простую модель для анализа финансовых данных.

Этот пример будет включать:
1. Загрузку финансовых данных (например, цен акций).
2. Вычисление простых технических индикаторов, например скользящего среднего.
3. Визуализацию данных.

Для этого мы будем использовать библиотеки pandas для обработки данных и matplotlib для визуализации. Обратите внимание, что для получения реальных финансовых данных обычно используются специализированные API или библиотеки, но в данном примере мы ограничимся использованием предварительно загруженных или сгенерированных данных для демонстрации.

Вот пример кода, демонстрирующего базовый подход к Quant Development:

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# Создание примера временного ряда данных (например, цен акций)
np.random.seed(0)
dates = pd.date_range('20230101', periods=100)
data = pd.DataFrame(np.random.randn(100, 1), index=dates, columns=['Price'])

# Вычисление скользящего среднего
data['Moving Average'] = data['Price'].rolling(window=5).mean()

# Визуализация данных
plt.figure(figsize=(10, 6))
plt.plot(data['Price'], label='Price')
plt.plot(data['Moving Average'], label='Moving Average')
plt.title('Stock Price and Moving Average')
plt.xlabel('Date')
plt.ylabel('Price')
plt.legend()
plt.show()

# Вывод первых нескольких строк данных
print(data.head())

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

2. Вычисление скользящего среднего: Я добавил столбец 'Moving Average', который представляет собой скользящее среднее цены акций за последние 5 дней. Это простой технический индикатор, часто используемый в анализе финансовых данных.

3. Визуализация данных: На графике показаны исходные цены акций и скользящее среднее. Визуализация помогает наглядно оценить поведение активов и тенденции на рынке.

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

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

В ИТ очень помогает знание английского, обучаться можно бесплатно в наших телеграмм каналах:

@KodduuEnglish - английские идиомы для увеличения словарного запаса

@KodduuEnglishQuiz - английские квизы для тренировки

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

Этот пример будет включать:
1. Генерацию искусственного временного ряда для цен акций.
2. Создание функций (например, лагов цен), которые могут быть использованы как предикторы.
3. Разбиение данных на обучающую и тестовую выборки.
4. Обучение модели линейной регрессии.
5. Оценку модели на тестовой выборке и визуализацию результатов.

Вот продолжение примера, демонстрирующего подход Quant Development с использованием линейной регрессии:

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# Создание искусственного временного ряда для цен акций
np.random.seed(0)
dates = pd.date_range('20230101', periods=100)
data = pd.DataFrame(np.random.randn(100, 1), index=dates, columns=['Price'])

data['Lag 1'] = data['Price'].shift(1)
data['Lag 2'] = data['Price'].shift(2)
data.dropna(inplace=True)  # Удаление строк с NaN

# Подготовка данных для модели линейной регрессии
X = data[['Lag 1', 'Lag 2']]
y = data['Price']

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

# Обучение модели линейной регрессии
model = LinearRegression()
model.fit(X_train, y_train)

# Прогнозирование и оценка модели
y_pred = model.predict(X_test)
mse = mean_squared_error(y_test, y_pred)

# Визуализация результатов
plt.figure(figsize=(10, 6))
plt.scatter(y_test, y_pred)
plt.xlabel('Actual Prices')
plt.ylabel('Predicted Prices')
plt.title(f'Actual vs Predicted Prices (MSE: {mse:.2f})')
plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'k--')
plt.show()

print("Mean Squared Error:", mse)

1. Подготовка данных: Я добавил два новых столбца, 'Lag 1' и 'Lag 2', которые представляют собой значения цен на один и два дня раньше соответственно. Эти значения используются в качестве предикторов (независимых переменных) для модели.

2. Разбиение на обучающую и тестовую выборки: Данные были разделены на обучающую (80%) и тестовую (20%) выборки.

3. Обучение модели линейной регрессии: Модель обучается на обучающей выборке.

4. Прогнозирование и оценка модели: Модель применяется к тестовой выборке, и её качество оценивается с помощью среднеквадратичной ошибки (MSE).

5. Визуализация результатов: На графике представлены фактические и предсказанные цены. Черная пунктирная линия указывает на идеальное совпадение между фактическими и прогнозируемыми значениями.

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

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