В наше время анализ социальных сетей и построение рекомендаций стали важными задачами для платформ, взаимодействующих с пользователями. Библиотека `networkx` позволяет моделировать такие системы с помощью графов, где узлы представляют пользователей, а рёбра — связи между ними. С networkx можно выявлять влиятельных пользователей, находить кластеры и строить алгоритмы рекомендаций.

### Установка

Установить networkx можно с помощью pip:

pip install networkx

### Пример: Моделирование Социальной Сети

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

import networkx as nx
import matplotlib.pyplot as plt

# Создаем граф
G = nx.Graph()

# Добавляем узлы (пользователей) и связи между ними
connections = [
    ("Alice", "Bob"),
    ("Alice", "Charlie"),
    ("Bob", "David"),
    ("Charlie", "David"),
    ("David", "Eve"),
    ("Eve", "Frank"),
    ("Frank", "Alice"),
    ("Charlie", "Eve"),
]
G.add_edges_from(connections)

# Визуализация сети
plt.figure(figsize=(8, 6))
nx.draw(G, with_labels=True, node_color='lightblue', node_size=2000, font_size=15)
plt.title("Социальная сеть пользователей")
plt.show()

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

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

Граф, визуализирующий отношения между пользователями.

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

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

# Вычисляем степень центральности для каждого узла
centrality = nx.degree_centrality(G)
print("Центральность пользователей:")
for user, central_value in centrality.items():
    print(f"{user}: {central_value:.2f}")

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

#### Функция для поиска рекомендаций

def recommend_friends(G, user):
    # Для каждого узла считаем общих друзей, которые не связаны с текущим пользователем
    potential_friends = {}
    for friend in G.neighbors(user):
        for friend_of_friend in G.neighbors(friend):
            if friend_of_friend != user and not G.has_edge(user, friend_of_friend):
                if friend_of_friend in potential_friends:
                    potential_friends[friend_of_friend] += 1
                else:
                    potential_friends[friend_of_friend] = 1

    # Сортируем по количеству общих друзей и возвращаем рекомендации
    recommendations = sorted(potential_friends.items(), key=lambda x: x[1], reverse=True)
    return [user for user, _ in recommendations]

# Рекомендуем друзей для пользователя "Alice"
recommended_friends = recommend_friends(G, "Alice")
print("Рекомендации для Alice:", recommended_friends)

Этот алгоритм выведет список пользователей, которых стоит порекомендовать Alice как потенциальных друзей, на основе общих связей. Например, если у Alice и David есть общие друзья, то David станет для нее рекомендуемым контактом.

### Применение: Поиск Кластеров (Групп)

Социальные сети часто образуют кластеры — группы людей с тесными связями внутри группы и меньшим количеством связей с пользователями за пределами группы. В networkx можно найти такие кластеры с помощью алгоритма связных компонент или более сложных алгоритмов, таких как Girvan-Newman.

# Используем связные компоненты для поиска групп в сети
clusters = list(nx.connected_components(G))
print("Кластеры пользователей в сети:", clusters)

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

### Расширенное Применение: Поиск путей для рекомендаций

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

# Ищем кратчайший путь между двумя пользователями
path = nx.shortest_path(G, source="Alice", target="Frank")
print("Кратчайший путь между Alice и Frank:", path)

Если между двумя пользователями можно найти путь, их можно рекомендовать друг другу, как потенциальных друзей на основе "косвенной связи".

### Заключение

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

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

Определение влиятельных пользователей.

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

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

import cv2
import numpy as np

class DroneDetector:
    def __init__(self):
        self.camera = cv2.VideoCapture(0)
        self.target_distance = 50  # Максимальная допустимая дистанция до цели
        self.known_width = 50  # Знакованный размер объекта в метрах
        self.known_distance = 10  # Знакованный расстояние до объекта в метрах

    def detect_drones(self):
        ret, frame = self.camera.read()
        
        if not ret:
            print("Ошибка при чтении кадра")
            return None
        
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        edges = cv2.Canny(gray, 100, 200)
        contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
        
        detected_drones = []
        
        for contour in contours:
            area = cv2.contourArea(contour)
            
            if area > 1000:  # Простое условие для определения крупных объектов
                x, y, w, h = cv2.boundingRect(contour)
                
                # Вычисление отношения размера объекта к размеру кадра
                ratio = max(w, h) / min(frame.shape[2], frame.shape[1])
                
                # Корректировка расстояния
                distance = np.sqrt(x**2 + y**2) * ratio
                
                if distance < self.target_distance:
                    drone_size = max(w, h)
                    drone_ratio = drone_size / self.known_width
                    
                    # Прогнозирование расстояния до дрона
                    predicted_distance = self.known_distance * drone_ratio
                    
                    print(f"Обнаружен потенциальный дрон на расстоянии {predicted_distance:.2f} метров")
                    
                    detected_drones.append({
                        'distance': predicted_distance,
                        'size': drone_size,
                        'ratio': drone_ratio
                    })
        
        return frame, detected_drones

    def display_frame(self):
        ret, frame = self.camera.read()
        
        if ret:
            cv2.imshow('Drone Camera', frame)
            
            if cv2.waitKey(1) & 0xFF == ord('q'):
                self.camera.release()
                cv2.destroyAllWindows()
        
        return frame

def main():
    detector = DroneDetector()

    while True:
        frame, detected_drones = detector.detect_drones()
        if frame is not None:
            detector.display_frame()
            
            if len(detected_drones) > 0:
                print("Детектированные дроны:")
                for drone in detected_drones:
                    print(f"- Расстояние: {drone['distance']:.2f} м, Размер: {drone['size']} пикселей, Соотношение: {drone['ratio']:.2f}")
            
            # Здесь можно добавить дополнительную логику обработки и действий
            
        else:
            print("Не удалось получить кадр")

if __name__ == "__main__":
    main()

### Ключевые особенности этого кода:

1. Класс DroneDetector: Создан класс для управления процессом обнаружения дронов.

2. Метод detect_drones():
- Читает кадр из камеры.
- Преобразует кадр в оттенки серого и применяет алгоритм Canny для выделения границ.
- Находит контуры крупных объектов.
- Вычисляет отношение размера объекта к размеру кадра.
- Корректирует расстояние, учитывая размер объекта.
- Предполагает расстояние до дрона на основе знаковых значений.

3. Метод display_frame():
- Отображает видеоизображение с камеры.
- Позволяет пользователю прервать работу приложения нажатием клавиши 'q'.

4. Главная функция main():
- Инициализирует объект DroneDetector.
- Запускает бесконечный цикл обнаружения и отображения дронов.

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

### Как работает обнаружение дронов:

1. Код ищет крупные объекты (с площадью более 1000 пикселей) в кадре.
2. Для каждого найденного объекта вычисляется соотношение его размера к размеру кадра.
3. Расстояние корректируется, умножая простое расстояние на это соотношение.
4. Предполагается расстояние до дрона на основе знаковых значений и соотношения размеров.

### Дополнительные возможности:

- Код предоставляет базовую структуру для дальнейшей разработки.
- Можно добавить дополнительную логику для безопасного подхода к обнаруженным дронам.
- Реализовать систему предупреждения о приближающихся дронах.
- Интегрировать систему распознавания дронов с использованием нейронных сетей для повышения точности.

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

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

Как работает обнаружение дронов:

1. Код ищет крупные объекты (с площадью более 1000 пикселей) в кадре.
2. Для каждого найденного объекта вычисляется соотношение его размера к размеру кадра.
3. Расстояние корректируется, умножая простое расстояние на это соотношение.
4. Предполагается расстояние до дрона на основе знаковых значений и соотношения размеров.

Доп.возможности:

- Код предоставляет базовую структуру для дальнейшей разработки.
- Можно добавить дополнительную логику для безопасного подхода к обнаруженным дронам.
- Реализовать систему предупреждения о приближающихся дронах.
- Интегрировать систему распознавания дронов с использованием нейронных сетей для повышения точности.

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

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

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

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

# Загрузка и подготовка данных
# Предположим, у нас есть данные о погоде с такими столбцами:
# "date", "temperature", "humidity", "wind_speed", "pressure"

# Загрузим примерные данные
data = pd.read_csv('weather_data.csv')
data['date'] = pd.to_datetime(data['date'])

# Выделяем день, месяц и год как отдельные признаки
data['day'] = data['date'].dt.day
data['month'] = data['date'].dt.month
data['year'] = data['date'].dt.year

# Убираем ненужные столбцы и определяем целевую переменную
X = data[['day', 'month', 'year', 'humidity', 'wind_speed', 'pressure']]
y = data['temperature']

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

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

# Прогнозируем на тестовой выборке
y_pred = model.predict(X_test)

# Оцениваем точность модели
mse = mean_squared_error(y_test, y_pred)
print(f"Mean Squared Error: {mse}")

# Пример прогноза на следующий день
next_day = pd.DataFrame({
    'day': [13],
    'month': [11],
    'year': [2024],
    'humidity': [65],  # Примерные значения
    'wind_speed': [5],
    'pressure': [1013]
})
next_day_prediction = model.predict(next_day)
print(f"Predicted temperature for next day: {next_day_prediction[0]:.2f}°C")

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

Для улучшения прогноза можно использовать сложные модели, такие как временные ряды или более мощные алгоритмы (например, Random Forest, XGBoost, или нейронные сети).

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

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

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation
from noise import pnoise2  # Убедитесь, что установлен пакет noise (pip install noise)

# Параметры сетки и шума
grid_size = 10
num_particles = 200
scale = 0.1  # Масштаб шума
speed = 0.05  # Скорость изменения шума
time_step = 0

# Инициализация начальных позиций частиц
particles_x = np.random.uniform(0, grid_size, num_particles)
particles_y = np.random.uniform(0, grid_size, num_particles)

# Функция для генерации поля ветра с использованием перлин-шума
def generate_wind_field(time):
    U = np.zeros((grid_size, grid_size))
    V = np.zeros((grid_size, grid_size))
    for i in range(grid_size):
        for j in range(grid_size):
            U[i, j] = pnoise2(i * scale, j * scale, octaves=3, base=int(time)) * 5
            V[i, j] = pnoise2(i * scale + 100, j * scale + 100, octaves=3, base=int(time)) * 5
    return U, V

# Настройка графика
fig, ax = plt.subplots(figsize=(8, 8))
ax.set_xlim(0, grid_size)
ax.set_ylim(0, grid_size)

# Начальная визуализация частиц и стрелок
scat = ax.scatter(particles_x, particles_y, color='blue', s=2)
U, V = generate_wind_field(time_step)
quiver = ax.quiver(np.linspace(0, grid_size, grid_size), np.linspace(0, grid_size, grid_size), U, V, color='red')

# Функция инициализации
def init():
    scat.set_offsets(np.c_[particles_x, particles_y])
    quiver.set_UVC(U, V)
    return scat, quiver

# Функция обновления анимации
def update(frame):
    global particles_x, particles_y, time_step
    U, V = generate_wind_field(time_step)
    time_step += speed

    # Обновление стрелок
    quiver.set_UVC(U, V)

    # Интерполяция скорости ветра для частиц
    particle_u = np.interp(particles_x, np.linspace(0, grid_size, grid_size), U[:, int(particles_y[0]) % grid_size])
    particle_v = np.interp(particles_y, np.linspace(0, grid_size, grid_size), V[int(particles_x[0]) % grid_size, :])

    # Обновление позиций частиц
    particles_x = (particles_x + particle_u * 0.1) % grid_size
    particles_y = (particles_y + particle_v * 0.1) % grid_size
    scat.set_offsets(np.c_[particles_x, particles_y])

    return scat, quiver

# Запуск анимации
ani = animation.FuncAnimation(fig, update, frames=200, init_func=init, interval=50, blit=True)

plt.show()

### Объяснение:

1. Поле ветра: Используем pnoise2 для создания переменных U и V, которые определяют горизонтальные и вертикальные компоненты скорости ветра. Значения U и V изменяются со временем, создавая динамическое поле ветра.

2. Частицы: Частицы (синие точки) движутся по направлению ветра, обновляя свои позиции на каждом кадре на основе текущего значения U и V.

3. Стрелки (quiver): Красные стрелки отображают направление и скорость ветра в каждом кадре, обновляясь вместе с полем ветра.

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

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

Анимация движения ветра. Код выше 👆👆👆

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

Пример кода для прогнозирования спроса на продукт с использованием временных рядов и модели ARIMA. Этот код поможет предсказать будущий спрос на продукт на основе предыдущих данных о продажах. ARIMA (AutoRegressive Integrated Moving Average) — популярная модель для анализа и прогнозирования временных рядов.

import pandas as pd
import numpy as np
from statsmodels.tsa.arima.model import ARIMA
import matplotlib.pyplot as plt
from sklearn.metrics import mean_squared_error

# Загрузка данных о продажах
# Предположим, у нас есть временной ряд с ежедневными данными о продажах
data = pd.read_csv('sales_data.csv')
data['date'] = pd.to_datetime(data['date'])
data.set_index('date', inplace=True)

# Визуализируем данные
plt.figure(figsize=(10, 6))
plt.plot(data, label='Daily Sales')
plt.title('Sales Data')
plt.xlabel('Date')
plt.ylabel('Sales')
plt.legend()
plt.show()

# Создание модели ARIMA
# (p, d, q) - параметры модели, их можно подбирать автоматически, но здесь поставим примерные значения
p, d, q = 5, 1, 2
model = ARIMA(data['sales'], order=(p, d, q))
fitted_model = model.fit()

# Прогноз на 30 дней вперед
forecast_steps = 30
forecast = fitted_model.forecast(steps=forecast_steps)

# Построение графика прогноза
plt.figure(figsize=(10, 6))
plt.plot(data, label='Historical Sales')
plt.plot(pd.date_range(data.index[-1], periods=forecast_steps+1, closed='right'), forecast, color='red', label='Forecast')
plt.title('Sales Forecast for Next 30 Days')
plt.xlabel('Date')
plt.ylabel('Sales')
plt.legend()
plt.show()

# Оценка точности модели (например, среднеквадратичная ошибка на последних 30 днях)
train_size = int(len(data) * 0.8)
train, test = data['sales'][:train_size], data['sales'][train_size:]
model = ARIMA(train, order=(p, d, q))
fitted_model = model.fit()
forecast_test = fitted_model.forecast(steps=len(test))
mse = mean_squared_error(test, forecast_test)
print(f"Mean Squared Error: {mse}")

### Объяснение:

1. Подготовка данных: Загружаем временной ряд продаж и визуализируем данные.
2. Создание модели: Настраиваем параметры модели ARIMA и обучаем её на исторических данных.
3. Прогноз: Строим прогноз на 30 дней вперед.
4. Оценка модели: Вычисляем среднеквадратичную ошибку (MSE) для тестовой выборки, чтобы оценить точность прогноза.

### Примечания:
- Параметры модели ARIMA (`p`, d, q`) можно подобрать автоматически с помощью библиотек, таких как `pmdarima, которая содержит функцию auto_arima, чтобы выбрать лучшие параметры на основе критериев оценки модели.
- Этот пример подходит для анализа и прогнозирования временных рядов, таких как продажи, спрос, посещаемость и другие временные данные.

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