Осенняя подборка курсов на Stepik:

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

👉 ЛИНК С ДОП.СКИДКОЙ 1675 РУБ 💰

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

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

👉 ЛИНК С ДОП.СКИДКОЙ 2275 РУБ 💰

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

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

👉 ЛИНК С ДОП.СКИДКОЙ 225 РУБ 💰

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

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

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

Программы:

👉 Junior Python Developer 🔥🔥

👉 ЛИНК С ДОП.СКИДКОЙ 1975 РУБ 💰

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

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

👉 ЛИНК С ДОП.СКИДКОЙ 2375 РУБ 💰

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

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

Еще пример кода на Python, демонстрирующий использование библиотеки Gensim для обработки естественного языка. В этом примере мы создадим модель тематического моделирования (LDA) для набора текстовых документов.

# Установка необходимых библиотек:
# pip install gensim nltk

import gensim
from gensim import corpora
from nltk.tokenize import word_tokenize
from nltk.corpus import stopwords
import nltk

# Загрузка стоп-слов и ресурсов NLTK
nltk.download('punkt')
nltk.download('stopwords')

# Пример текстовых документов
documents = [
    "Машинное обучение предоставляет системам возможность автоматически учиться и совершенствоваться из опыта без явного программирования.",
    "Искусственный интеллект является ветвью компьютерной науки, которая занимается созданием интеллектуальных машин.",
    "Обработка естественного языка позволяет компьютерам понимать человеческий язык.",
    "Глубокое обучение является подмножеством машинного обучения, использующего нейронные сети.",
    "Целью искусственного интеллекта является создание систем, способных выполнять задачи, которые обычно требуют человеческого интеллекта."
]

# Предварительная обработка текстов
stop_words = set(stopwords.words('russian'))

def preprocess(text):
    tokens = word_tokenize(text.lower())
    tokens = [token for token in tokens if token.isalpha() and token not in stop_words]
    return tokens

processed_texts = [preprocess(doc) for doc in documents]

# Создание словаря и корпуса
dictionary = corpora.Dictionary(processed_texts)
corpus = [dictionary.doc2bow(text) for text in processed_texts]

# Построение модели LDA
lda_model = gensim.models.LdaModel(corpus, num_topics=2, id2word=dictionary, passes=15)

# Вывод основных тем
topics = lda_model.print_topics(num_words=4)
for topic in topics:
    print(f"Тема {topic[0]}: {topic[1]}")

# Пример классификации нового документа
new_doc = "Нейронные сети используются в глубоких моделях машинного обучения."
new_doc_processed = preprocess(new_doc)
new_doc_bow = dictionary.doc2bow(new_doc_processed)
topics_new_doc = lda_model.get_document_topics(new_doc_bow)

print("\nРаспределение тем для нового документа:")
for topic_num, prob in topics_new_doc:
    print(f"Тема {topic_num}: вероятность {prob}")

Особенности использования Gensim:

1. Предварительная обработка текста:
- Токенизация и нормализация: Используем NLTK для разбиения текста на слова и приведения их к нижнему регистру.
- Удаление стоп-слов и небуквенных символов: Это сокращает шум в данных и улучшает качество модели.

2. Создание словаря и корпуса:
- Словарь (`Dictionary`): Хранит уникальные слова и присваивает им идентификаторы.
- Корпус: Представляет каждый документ как мешок слов (bag-of-words), что является необходимым форматом для LDA.

3. Построение модели LDA:
- `LdaModel`: Создает модель латентного размещения Дирихле для выявления скрытых тем.
- Параметры модели:
- num_topics: количество тем для обнаружения.
- passes: количество проходов по корпусу для обучения модели.

4. Интерпретация результатов:
- Темы: Отображаются наиболее значимые слова для каждой выявленной темы.
- Классификация нового документа: Оценивается вероятность принадлежности документа к выявленным темам.

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

- Эффективность при работе с большими данными: Gensim оптимизирован для обработки больших корпусов без необходимости загружать все данные в оперативную память.
- Поддержка различных моделей: Помимо LDA, Gensim включает реализации Word2Vec, FastText и других моделей для векторизации и тематического анализа.
- Интеграция с другими инструментами: Легко сочетается с библиотеками NLTK и NumPy для расширения возможностей обработки и анализа данных.

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

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

Заключение:

Gensim является мощным инструментом для тематического моделирования и анализа текстовых данных. Его эффективность и гибкость делают его подходящим выбором для обработки больших объемов информации и выполнения сложных задач в области обработки естественного языка.

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

Начали писать курс по Data Science в Python 😎. Пока базовый курс 🧦. Тема на самом деле сложная, но очень интересная 😋 Python лидирует в области анализа данных. Его типы данных и библиотеки являются одними из самых удобных и одновременно простых для начала работы в области Data Science, но кстати, они не самые производительные. Существует, например, Julia, который значительно быстрее на больших наборах данных. В конце концов, никто не отменял C ➕ CUDA. Но мы все знаем, что удобство и возможность быстро начать работать побеждают потенциальную производительность. Примером тому является Excel, который также используется для Data Science, возможно даже чаще, чем Python 🙂

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

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

import numpy as np
from scipy import stats
import matplotlib.pyplot as plt

# Генерация случайных данных для двух групп
np.random.seed(42)
group1 = np.random.normal(loc=50, scale=10, size=100)  # Первая группа: нормальное распределение
group2 = np.random.normal(loc=55, scale=15, size=100)  # Вторая группа: другое распределение

# 1. Проверка нормальности распределения (тест Шапиро-Уилка)
stat1, p_value1 = stats.shapiro(group1)
stat2, p_value2 = stats.shapiro(group2)

print(f"Тест Шапиро-Уилка для группы 1: W={stat1}, p-value={p_value1}")
print(f"Тест Шапиро-Уилка для группы 2: W={stat2}, p-value={p_value2}")

# 2. Тест на равенство дисперсий (тест Левена)
levene_stat, levene_p_value = stats.levene(group1, group2)
print(f"Тест Левена: stat={levene_stat}, p-value={levene_p_value}")

# 3. Проверка гипотезы о равенстве средних значений (t-тест)
t_stat, t_p_value = stats.ttest_ind(group1, group2)
print(f"T-тест: stat={t_stat}, p-value={t_p_value}")

# 4. Построение гистограмм для визуализации распределения
plt.hist(group1, alpha=0.5, label='Group 1', bins=15)
plt.hist(group2, alpha=0.5, label='Group 2', bins=15)
plt.title('Распределение значений в двух группах')
plt.legend()
plt.show()

# 5. Корреляционный анализ (коэффициент Пирсона)
x = np.random.rand(100)
y = 2 * x + np.random.normal(0, 0.1, 100)
pearson_corr, pearson_p_value = stats.pearsonr(x, y)
print(f"Коэффициент корреляции Пирсона: r={pearson_corr}, p-value={pearson_p_value}")

# 6. Проверка независимости категориальных переменных (хи-квадрат тест)
observed = np.array([[20, 15], [10, 25]])
chi2_stat, chi2_p_value, dof, expected = stats.chi2_contingency(observed)
print(f"Хи-квадрат тест: chi2={chi2_stat}, p-value={chi2_p_value}, degrees of freedom={dof}")
print("Ожидаемые значения:")
print(expected)

### Описание и особенности анализа

1. Тест Шапиро-Уилка — проверяет гипотезу о нормальности распределения данных. Если p-value меньше 0.05, мы отвергаем гипотезу о нормальности.
2. Тест Левена — проверяет гипотезу о равенстве дисперсий между двумя группами. Низкий p-value говорит о том, что дисперсии значимо различаются.
3. t-тест — тестирует гипотезу о равенстве средних значений двух групп. Используется, если дисперсии равны и данные имеют нормальное распределение.
4. Коэффициент корреляции Пирсона — оценивает степень линейной зависимости между двумя переменными. Значение коэффициента находится в диапазоне от -1 до 1.
5. Хи-квадрат тест — используется для проверки зависимости между категориальными переменными.

### Преимущества и особенности использования SciPy:
- Разнообразие тестов: библиотека SciPy предоставляет широкий выбор статистических тестов и функций для анализа данных, от простых t-тестов до более сложных непараметрических тестов.
- Гибкость: SciPy позволяет анализировать как непрерывные, так и категориальные данные, что делает ее полезной для различных типов задач.
- Легкость интеграции: SciPy легко интегрируется с другими библиотеками Python, такими как NumPy и Matplotlib, что позволяет проводить как численные расчеты, так и визуализацию данных.

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

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

Продолжаем писать курс по Data Science в Python 😎 Написали про NumPy 36 уоков и задач 👍 Переходим к Pandas 🧐

Что такое NumPy - это Numerical Python, то есть библиотека для работы с числами. Основа тут N-мерные массивы, которые можно перемножать, искать max, min, среднее. Искать корреляции между строками массивов и т.д. Работает очень быстро, по сравнению со стандартными типами данных Python. Очень круто для научных и прочих технических задач с циферами. Ну прям летает оно, потому что массивы immutable и хранятся в памяти подряд.

А вот Pandas многим понравиться еще больше, потому что это Ваши любымие таблицы (прям как в Excel). Тут можно будет впихнуть любые типы данных, включая пустые значения, которые NumPy по умолчанию не поддерживает 🤨Можно прям взять вашу любимубю табличку Excel, и сразу сюда подгрузить, можно и из CSV затянуть данные. Но придется заплатить производительностью - все будет медленее, чем в NumPy. Зато индексацию по вашим любимым столбикам можно будет сделать. Сам люблю, когда большой уже Excel файл тормозит, его втянуть в Pandas и выжать из него все данные которые мне нужны 😀

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

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

### Пример кода на Python с PyMC3:

import numpy as np
import matplotlib.pyplot as plt
import pymc3 as pm
import arviz as az

# Генерация синтетических данных
np.random.seed(42)
size = 100
X = np.random.randn(size)  # случайные входные данные
true_intercept = 1.0  # истинное значение интерцепта
true_slope = 2.5  # истинное значение коэффициента наклона
true_sigma = 0.5  # истинное значение стандартного отклонения ошибки
Y = true_intercept + true_slope * X + np.random.normal(scale=true_sigma, size=size)

# Построение модели в PyMC3
with pm.Model() as model:
    # Определяем априорные распределения для параметров
    intercept = pm.Normal("intercept", mu=0, sigma=10)
    slope = pm.Normal("slope", mu=0, sigma=10)
    sigma = pm.HalfNormal("sigma", sigma=1)
    
    # Линейная модель
    mu = intercept + slope * X
    
    # Наблюдения с ошибками
    Y_obs = pm.Normal("Y_obs", mu=mu, sigma=sigma, observed=Y)
    
    # Запуск выборки с помощью метода NUTS (No-U-Turn Sampler)
    trace = pm.sample(2000, tune=1000, return_inferencedata=True)
    
# Визуализация результатов
az.plot_trace(trace)
plt.show()

# Визуализация апостериорных предсказаний
with model:
    pm.plot_posterior_predictive_glm(trace, samples=100, 
                                     label='Posterior predictive regression lines',
                                     eval=np.linspace(-3, 3, 100))
plt.scatter(X, Y, c='r', label='Observed data')
plt.legend()
plt.show()

# Вывод статистик выборки
print(az.summary(trace))

### Описание анализа

#### Шаги:
1. Генерация данных: Мы создаем синтетические данные, которые моделируют линейную зависимость между независимой переменной \(X\) и зависимой переменной \(Y\) с добавлением случайного шума.
2. Модель в PyMC3:
- Задаем априорные распределения для параметров нашей модели: интерцепта, коэффициента наклона и стандартного отклонения ошибки (sigma).
- Выражаем зависимость через линейную модель.
- Определяем наблюдения как нормально распределенные вокруг линейной модели с неизвестной дисперсией (sigma).
3. Запуск выборки: Используем метод NUTS для выполнения байесовского вывода. Этот метод является адаптивной версией метода Гамильтоновой Монте-Карло (HMC), который эффективно исследует пространство параметров.
4. Визуализация результатов: Мы визуализируем траектории выборки и построенные регрессионные линии с учетом апостериорных распределений.

#### Особенности использования PyMC3:
1. Байесовский подход: В отличие от частотных методов, PyMC3 реализует байесовский подход к статистическому анализу, что позволяет работать с неопределенностями и априорными предположениями. Это особенно полезно в случаях, когда данные ограничены или сложно структурированы.
2. Гибкость моделей: PyMC3 позволяет строить сложные иерархические модели с нелинейными зависимостями и легко работать с различными типами распределений для параметров. Модель может быть расширена для работы с любыми вероятностными зависимостями.
3. Мощные алгоритмы выборки: PyMC3 использует современные алгоритмы выборки, такие как NUTS, который помогает эффективно исследовать сложные пространства параметров, особенно когда обычные методы, такие как MCMC, не справляются.
4. Визуализация неопределенности: Визуализация результатов выборки, особенно апостериорных предсказаний, дает представление не только о средних значениях, но и о вариациях и неопределенности оценок, что является мощным инструментом для принятия решений в условиях неопределенности.

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

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

Пример кода для проведения статистического анализа с использованием библиотеки PyStan (интерфейс Python для языка моделирования Stan), демонстрирующий выполнение байесовской линейной регрессии.

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

# Генерация синтетических данных
np.random.seed(42)
size = 100
X = np.random.randn(size)
true_intercept = 1.0
true_slope = 2.5
true_sigma = 0.5
Y = true_intercept + true_slope * X + np.random.normal(0, true_sigma, size)

# Определяем модель на языке Stan
stan_model_code = """
data {
    int<lower=0> N;        // Количество наблюдений
    vector[N] x;           // Независимая переменная
    vector[N] y;           // Зависимая переменная
}
parameters {
    real alpha;            // Интерцепт
    real beta;             // Коэффициент наклона
    real<lower=0> sigma;   // Стандартное отклонение
}
model {
    y ~ normal(alpha + beta * x, sigma);  // Линейная модель с нормальным шумом
}
"""

# Подготовка данных для передачи в Stan
stan_data = {
    'N': size,
    'x': X,
    'y': Y
}

# Компиляция и запуск модели в Stan
stan_model = pystan.StanModel(model_code=stan_model_code)
fit = stan_model.sampling(data=stan_data, iter=2000, chains=4)

# Вывод результатов выборки
print(fit)

# Получение результатов выборки для параметров модели
fit_results = fit.extract()

# Визуализация апостериорных предсказаний
alpha_samples = fit_results['alpha']
beta_samples = fit_results['beta']

x_pred = np.linspace(-3, 3, 100)
y_pred = np.zeros((len(alpha_samples), len(x_pred)))

for i in range(len(alpha_samples)):
    y_pred[i, :] = alpha_samples[i] + beta_samples[i] * x_pred

# Построение графика с доверительными интервалами
plt.plot(x_pred, np.mean(y_pred, axis=0), label='Posterior mean', color='blue')
plt.fill_between(x_pred, np.percentile(y_pred, 2.5, axis=0), np.percentile(y_pred, 97.5, axis=0), color='blue', alpha=0.3)
plt.scatter(X, Y, c='r', label='Observed data')
plt.title('Байесовская линейная регрессия с PyStan')
plt.legend()
plt.show()

### Описание анализа

#### Шаги:
1. Генерация данных: Мы создаем синтетические данные с линейной зависимостью между независимой переменной \(X\) и зависимой переменной \(Y\) с добавлением случайного шума.
2. Модель на языке Stan: Мы описываем байесовскую линейную регрессию с нормальным распределением шума в модели. В этой модели есть три параметра: интерцепт (alpha), коэффициент наклона (beta) и стандартное отклонение ошибки (sigma).
3. Подготовка данных для Stan: Мы передаем данные, такие как количество наблюдений и сами данные, в формате, понятном Stan.
4. Запуск выборки: Мы используем алгоритм HMC (Гамильтонова Монте-Карло) для выполнения байесовского вывода с использованием выборки параметров модели. Параметры выборки будут использованы для построения апостериорных распределений.
5. Визуализация результатов: Мы визуализируем предсказания модели, построенные на основе апостериорных распределений, с доверительными интервалами. Это позволяет оценить неопределенность предсказаний.

### Особенности PyStan:
1. Высокая производительность: PyStan является оберткой над Stan, который использует высокоэффективные алгоритмы Гамильтоновой Монте-Карло для проведения выборки из апостериорных распределений. Это делает его особенно полезным для сложных и вычислительно тяжелых моделей.
2. Явное описание модели: Stan использует свой язык для определения моделей, что делает описания вероятностных моделей более строгими и легко читаемыми. Это позволяет четко задавать как априорные распределения, так и зависимость между переменными.
3. Поддержка сложных иерархических моделей: PyStan может использоваться для моделирования сложных иерархических моделей, что делает его подходящим для задач с большим количеством параметров и зависимостей.
4. Мощные методы байесовского вывода: Используя такие алгоритмы, как NUTS и HMC, PyStan обеспечивает эффективный байесовский анализ, особенно в пространствах параметров высокой размерности.

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

Начальные требования для курса Data Science в Python пришлось немного поднять, не можем же мы повторять здесь все что есть в других курсах для новчиков 🤷‍♀️ Вся база по Python уже ведь есть тут.

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

Ниже пример кода на Python для проведения статистического анализа с использованием библиотеки Statsmodels. Мы проведем линейную регрессию и некоторые дополнительные статистические тесты.

import numpy as np
import statsmodels.api as sm
import statsmodels.formula.api as smf
import matplotlib.pyplot as plt

# Генерация синтетических данных
np.random.seed(42)
size = 100
X = np.random.normal(0, 1, size)
true_intercept = 2.0
true_slope = 3.5
Y = true_intercept + true_slope * X + np.random.normal(0, 1, size)

# Добавление константы (интерцепта) в данные
X_with_const = sm.add_constant(X)

# Создание модели линейной регрессии
model = sm.OLS(Y, X_with_const)
results = model.fit()

# Вывод результатов регрессии
print(results.summary())

# Построение графика
plt.scatter(X, Y, label='Observed data')
plt.plot(X, results.fittedvalues, color='red', label='Fitted line')
plt.title('Линейная регрессия с использованием Statsmodels')
plt.xlabel('X')
plt.ylabel('Y')
plt.legend()
plt.show()

# Проверка остатков на нормальность (тест Джарка-Бера)
jb_test_stat, jb_p_value, skew, kurtosis = sm.stats.jarque_bera(results.resid)
print(f"Тест Джарка-Бера: stat={jb_test_stat}, p-value={jb_p_value}")

# Тест на гетероскедастичность (тест Бреуша-Пагана)
_, bp_p_value, _, _ = sm.stats.het_breuschpagan(results.resid, results.model.exog)
print(f"Тест Бреуша-Пагана: p-value={bp_p_value}")

### Описание анализа

#### Шаги:

1. Генерация данных: Мы создаем синтетические данные, которые моделируют линейную зависимость между независимой переменной \(X\) и зависимой переменной \(Y\) с добавлением случайного шума. Эти данные мы будем использовать для построения регрессионной модели.
2. Добавление константы: В Statsmodels для линейной регрессии нужно явно добавить константу (интерцепт) в данные с помощью функции sm.add_constant().
3. Построение модели линейной регрессии: Мы используем метод наименьших квадратов (OLS) для построения модели. sm.OLS() создает объект модели, а метод fit() выполняет оценку параметров модели.
4. Вывод результатов: Результаты регрессии включают оценки параметров модели (интерцепта и коэффициента наклона), а также различные статистические показатели, такие как \(R^2\), t-статистика, F-статистика и p-значения.
5. Визуализация: Мы строим график исходных данных и линии регрессии, чтобы увидеть, как хорошо модель описывает данные.
6. Тест Джарка-Бера: Этот тест проверяет, следуют ли остатки нормальному распределению. Это важно, так как одно из предположений линейной регрессии — нормальность ошибок.
7. Тест Бреуша-Пагана: Этот тест проверяет наличие гетероскедастичности (изменяющейся дисперсии остатков). Если гетероскедастичность присутствует, то стандартные ошибки оценок могут быть неверными.

### Особенности использования Statsmodels:

1. Мощный инструмент для линейных и нелинейных моделей: Statsmodels предоставляет широкие возможности для создания как простых линейных регрессионных моделей, так и более сложных статистических моделей, таких как логистическая регрессия, временные ряды, иерархические модели и другие.

2. Поддержка формул: В дополнение к традиционному API, Statsmodels поддерживает API на основе формул через модуль statsmodels.formula.api. Это позволяет удобно задавать модели в стиле R, например: model = smf.ols('Y ~ X', data=data).

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

4. Информативные отчеты: Результаты модели в Statsmodels включают детализированные таблицы с основными статистиками, такими как коэффициенты, доверительные интервалы, статистики t и F, p-значения, \(R^2\), и многое другое. Это делает Statsmodels особенно полезной для выполнения регрессионного анализа с акцентом на интерпретацию результатов.

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

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

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from lifelines import KaplanMeierFitter, CoxPHFitter

# Генерация синтетических данных
np.random.seed(42)
n = 100  # количество наблюдений
data = pd.DataFrame({
    'duration': np.random.exponential(10, size=n),  # продолжительность времени до события
    'event': np.random.binomial(1, 0.8, size=n),    # индикатор события (1 - событие произошло, 0 - цензурировано)
    'age': np.random.normal(50, 10, size=n),        # возраст как ковариата
    'treatment': np.random.binomial(1, 0.5, size=n) # лечение (0 или 1)
})

# Каплан-Майеровская оценка
kmf = KaplanMeierFitter()
kmf.fit(durations=data['duration'], event_observed=data['event'])

# Построение графика Каплан-Майеровской кривой
kmf.plot_survival_function()
plt.title('Каплан-Майеровская оценка')
plt.xlabel('Время')
plt.ylabel('Вероятность выживания')
plt.show()

# Каплан-Майеровская оценка для двух групп (лечение vs без лечения)
kmf_treatment = KaplanMeierFitter()
kmf_no_treatment = KaplanMeierFitter()

# Разделение данных по группам
treatment_group = data['treatment'] == 1
no_treatment_group = data['treatment'] == 0

# Построение кривых выживания для обеих групп
kmf_treatment.fit(durations=data['duration'][treatment_group], event_observed=data['event'][treatment_group], label='Лечение')
kmf_no_treatment.fit(durations=data['duration'][no_treatment_group], event_observed=data['event'][no_treatment_group], label='Без лечения')

# Визуализация
kmf_treatment.plot_survival_function()
kmf_no_treatment.plot_survival_function()
plt.title('Каплан-Майеровская оценка (лечение vs без лечения)')
plt.xlabel('Время')
plt.ylabel('Вероятность выживания')
plt.show()

# Регрессия пропорциональных рисков Кокса
cph = CoxPHFitter()
cph.fit(data, duration_col='duration', event_col='event')
cph.print_summary()

# Визуализация коэффициентов модели Кокса
cph.plot()
plt.title('Коэффициенты регрессии Кокса')
plt.show()

### Описание анализа

#### Шаги:
1. Генерация данных: Мы создаем синтетические данные, которые включают время до события (например, смерть или отказ оборудования), индикатор события (1 — событие произошло, 0 — цензурирование), возраст участников и индикатор лечения.
2. Каплан-Майеровская оценка:
- Каплан-Майеровский метод — это популярный непараметрический метод для оценки функции выживания. Мы применяем его к нашим данным, чтобы оценить вероятность выживания на каждом этапе времени.
- Мы также сравниваем выживаемость между двумя группами: тех, кто получал лечение, и тех, кто не получал лечение.
3. Регрессия пропорциональных рисков Кокса:
- Регрессия Кокса является полупараметрическим методом, который используется для оценки зависимости времени до события от ковариат (например, возраста или лечения). В модели Кокса не предполагается форма базовой функции интенсивности.
- Мы выполняем регрессию Кокса, чтобы понять, как лечение и возраст влияют на вероятность наступления события.

#### Особенности использования Lifelines:
1. Простота использования: Lifelines предлагает простые и интуитивные инструменты для выполнения анализа выживаемости. Это делает его отличным выбором для задач анализа выживаемости, как с реальными, так и с синтетическими данными.

2. Каплан-Майеровская оценка: Этот метод позволяет оценивать функцию выживания и сравнивать выживаемость между различными группами. Визуализация с помощью Lifelines позволяет легко интерпретировать результаты.

3. Регрессия пропорциональных рисков Кокса: Модель Кокса — один из самых популярных методов анализа выживаемости, и Lifelines предоставляет удобный интерфейс для создания и интерпретации таких моделей. Она помогает понять влияние ковариат на выживаемость.

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

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

Lifelines — это мощный инструмент для анализа данных выживаемости, который предлагает удобные функции для выполнения Каплан-Майеровской оценки, регрессии Кокса и других методов анализа событий.

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

Пишем Data Science в Python дальше. В Pandas главное выбрать правильный формат создания данных - построчный 👆Единственный вариант когда вам может подойти создание по стоблцам - это статические данные, которые вы грузите из внешнки, уже хранящиеся в таком формате (че это за данные такие? 🤨), и у вас этих данных очень дофига, то есть для вас критична скорость создания самого Date Set, и вы будете данные просто анализировать без изменений. Ну и если памяти у Вас мало, потому что вы оказались заперты с 90х в лаборотрии с Pentium 1 с 32MB RAM и кнопкой Turbo 😆

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

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

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

# Генерация синтетических данных
np.random.seed(42)
data = pd.DataFrame({
    'group1': np.random.normal(50, 10, 30),  # Группа 1
    'group2': np.random.normal(55, 15, 30),  # Группа 2
    'group3': np.random.normal(60, 5, 30)    # Группа 3
})

# 1. Проверка нормальности распределения (тест Шапиро-Уилка)
normality_test_group1 = pg.normality(data['group1'])
normality_test_group2 = pg.normality(data['group2'])
normality_test_group3 = pg.normality(data['group3'])

print("Тест Шапиро-Уилка для группы 1:", normality_test_group1)
print("Тест Шапиро-Уилка для группы 2:", normality_test_group2)
print("Тест Шапиро-Уилка для группы 3:", normality_test_group3)

# 2. Проверка равенства дисперсий (тест Левена)
levene_test = pg.homoscedasticity(data)
print("\nТест Левена на равенство дисперсий между группами:\n", levene_test)

# 3. Однофакторный ANOVA
anova_results = pg.anova(dv='group1', between='group2', data=data)
print("\nРезультаты однофакторного ANOVA:\n", anova_results)

# 4. Парный t-тест (сравнение двух групп)
ttest_results = pg.ttest(data['group1'], data['group2'])
print("\nРезультаты парного t-теста:\n", ttest_results)

# 5. Корреляционный анализ (коэффициент Пирсона)
correlation = pg.corr(data['group1'], data['group3'])
print("\nКоэффициент корреляции Пирсона между группой 1 и группой 3:\n", correlation)

# 6. Визуализация данных и результатов анализа
plt.hist(data['group1'], alpha=0.5, label='Group 1', bins=10)
plt.hist(data['group2'], alpha=0.5, label='Group 2', bins=10)
plt.hist(data['group3'], alpha=0.5, label='Group 3', bins=10)
plt.title('Распределение значений в группах')
plt.legend()
plt.show()

### Описание анализа

#### Шаги:

1. Проверка нормальности распределения (тест Шапиро-Уилка):
- Тест Шапиро-Уилка проверяет гипотезу о том, что данные имеют нормальное распределение. Если p-value < 0.05, то гипотеза о нормальности отвергается.

2. Проверка равенства дисперсий (тест Левена):
- Тест Левена используется для проверки гомогенности дисперсий между несколькими группами. Он особенно полезен перед проведением ANOVA, так как одно из предположений ANOVA заключается в равенстве дисперсий.

3. Однофакторный ANOVA:
- Однофакторный дисперсионный анализ (ANOVA) проверяет, различаются ли средние значения между несколькими группами. Если p-value < 0.05, то существует значимое различие между группами.

4. Парный t-тест:
- t-тест используется для проверки, есть ли значимое различие между средними значениями двух групп. В Pingouin можно легко выполнить парный t-тест для сравнения двух выборок.

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

#### Особенности использования Pingouin:

1. Простота использования: Pingouin разработан как удобный инструмент для выполнения статистического анализа с минимальным количеством кода. Он интуитивен и легко интегрируется с pandas, что делает его очень удобным для пользователей Python.

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

3. Дополнительные метрики и эффекты: Многие тесты в Pingouin автоматически предоставляют полезные метрики, такие как размеры эффекта, доверительные интервалы и другие важные статистические параметры. Это особенно полезно для интерпретации результатов анализа.

4. Поддержка повторных измерений: Pingouin отлично справляется с задачами, включающими повторные измерения, такие как парные t-тесты, тесты Фридмана и другие методы анализа для связанных данных.

5. Легкость интеграции с визуализацией: Результаты Pingouin легко визуализировать с помощью библиотек, таких как Matplotlib и Seaborn, что позволяет эффективно комбинировать аналитическую мощь с наглядностью.

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

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

Средний курс на Stepik имеет 200-300 уроков/тестов/задач. Мы делаем упор на задачах, чтобы писать код. Вот уже в Data Science в Python около 100 уроков/тестов/задач 🧐

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

Scrapy — это мощный и быстрый фреймворк для веб-скрейпинга на Python. Он позволяет эффективно собирать данные с веб-сайтов и структурировать их в нужном формате.

Ниже представлен пример простого паука, который собирает заголовки и ссылки статей с главной страницы новостного сайта:

import scrapy

class NewsSpider(scrapy.Spider):
    name = "news"

    start_urls = [
        'https://example-news-website.com/',
    ]

    def parse(self, response):
        for article in response.css('div.article'):
            yield {
                'title': article.css('h2.title::text').get(),
                'link': article.css('a::attr(href)').get(),
            }

        next_page = response.css('a.next::attr(href)').get()
        if next_page is not None:
            yield response.follow(next_page, self.parse)

Особенности данного примера:

1. Класс Spider: Создаем класс NewsSpider, наследуемый от scrapy.Spider, и задаем уникальное имя паука name = "news".

2. Начальные URL: Список start_urls содержит страницы, с которых паук начнет обход.

3. Метод `parse`: Основной метод, который обрабатывает ответ от каждого запроса. Здесь мы используем CSS-селекторы для извлечения данных.

4. Извлечение данных: В цикле for мы проходим по каждому элементу статьи и используем yield для возвращения словаря с данными.

5. Пагинация: Проверяем наличие ссылки на следующую страницу и используем response.follow() для перехода, что обеспечивает рекурсивный обход.

Как запустить паука:

Сохраните код в файл news_spider.py и выполните команду в терминале:

scrapy runspider news_spider.py -o articles.json

Это запустит паука и сохранит собранные данные в файл articles.json.

Особенности Scrapy:

- Асинхронность: Scrapy основан на асинхронной модели, что позволяет выполнять множество запросов одновременно и ускоряет процесс сбора данных.

- Легкость масштабирования: Фреймворк позволяет легко настраивать количество параллельных запросов и другие параметры производительности.

- Встроенные инструменты: Имеет мощные средства для обработки ошибок, повторных попыток, управления сессиями и кук.

- Расширяемость: Поддерживает Middleware, Pipelines и расширения, позволяющие добавлять дополнительную функциональность.

- Сообщество и документация: Обширная документация и активное сообщество упрощают решение возникающих вопросов.

Заключение

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

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

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

Ниже приведен пример кода на Python, который использует Selenium для извлечения названий и цен продуктов с динамического сайта:

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.chrome.options import Options

# Настройка опций браузера
chrome_options = Options()
chrome_options.add_argument('--headless')  # Режим без GUI (необязательно)

# Инициализация веб-драйвера для Chrome
driver = webdriver.Chrome(options=chrome_options)

try:
    # Открываем веб-сайт
    driver.get('https://example-ecommerce-site.com')

    # Явное ожидание загрузки элементов (например, 10 секунд)
    driver.implicitly_wait(10)

    # Находим все элементы с продуктами
    products = driver.find_elements(By.CLASS_NAME, 'product-item')

    # Извлекаем данные о каждом продукте
    for product in products:
        title = product.find_element(By.CLASS_NAME, 'product-title').text
        price = product.find_element(By.CLASS_NAME, 'product-price').text
        print(f'Название: {title}, Цена: {price}')

finally:
    # Закрываем браузер
    driver.quit()

Особенности данного примера:

1. Инициализация WebDriver: Используем webdriver.Chrome() для запуска браузера Chrome. С помощью Options можно задать дополнительные параметры, например, запуск в фоновом режиме без интерфейса (`--headless`).

2. Открытие веб-сайта: Метод get() загружает страницу по указанному URL.

3. Ожидание загрузки элементов: Используем implicitly_wait(10), чтобы подождать до 10 секунд загрузки необходимых элементов на странице.

4. Поиск элементов: Метод find_elements() находит все элементы, соответствующие заданному селектору. В данном случае ищем продукты по классу product-item.

5. Извлечение информации: Для каждого продукта находим элементы с названием и ценой по соответствующим классам и извлекаем текст с помощью .text.

6. Обработка исключений: Используем блок try...finally для гарантированного закрытия браузера, даже если в процессе возникнет ошибка.

Особенности использования Selenium для веб-скрейпинга:

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

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

- Ожидания: Поддержка явных (`WebDriverWait`) и неявных (`implicitly_wait`) ожиданий для синхронизации с динамическим контентом.

- Скриншоты: Возможность делать скриншоты страниц для отладки с помощью метода save_screenshot().

- Настройка браузера: Поддержка различных браузеров (Chrome, Firefox, Edge и др.) и возможность настройки параметров запуска.

Важно учитывать при использовании Selenium:

- Производительность: Запуск полноценного браузера требует больше ресурсов и времени по сравнению с библиотеками, работающими напрямую с HTTP-запросами (например, Requests).

- Правовые аспекты: Необходимо соблюдать правила использования сайтов и учитывать законодательство о защите данных. Рекомендуется проверять файл robots.txt и условия обслуживания сайта.

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

- Сложность установки: Требуется установка веб-драйверов (например, ChromeDriver для Chrome), что может добавить сложности при разворачивании на сервере или в контейнере Docker.

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

NumPy и Pandas в "Data Science в Python" закончен 👍👍👍

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