Skip to content
TheChatArchiveThe Chat Archive
o1-mini-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

Привет, сделай ИИ который предсказывает курс биткоина на час вперед Развернем все дело…

  1. User

    Привет, сделай ИИ который предсказывает курс биткоина на час вперед Развернем все дело на кагл Данные парсим с yfinance После парса сохраняем в файл что б каждый раз все не загружать а подтягиваем только новое Явно задаем использование GPU/TPU если можем Модель LSTM Среди эпох выбираем с меньшей погрешностью Графиков выводи 3 За последний год сравнение предсказаний с реальностью За неделею Сутки где половина это реальность и прогноз половина только прогноз Выводим предсказание на следующий час Выводим текущее время машины

  2. Assistant

    Привет! Давайте создадим модель ИИ, которая будет предсказывать курс биткоина на час вперед, используя LSTM. Мы будем использовать Python и библиотеки TensorFlow/Keras для построения модели, yfinance для получения данных, и matplotlib для визуализации результатов. Также настроим сохранение данных, чтобы загружать только новые записи, и используем GPU, если он доступен.

    Ниже приведен полный скрипт, который можно запустить на Kaggle.

    Шаги:

    1. Установка необходимых библиотек
    2. Загрузка и обновление данных
    3. Предобработка данных
    4. Построение и обучение модели LSTM
    5. Оценка модели и визуализация результатов
    6. Предсказание на следующий час и вывод текущего времени

    Полный Скрипт:

    # Установка необходимых библиотек
    !pip install yfinance
    !pip install --upgrade tensorflow
    
    import os
    import yfinance as yf
    import pandas as pd
    import numpy as np
    import tensorflow as tf
    from tensorflow.keras.models import Sequential
    from tensorflow.keras.layers import LSTM, Dense
    from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint
    from sklearn.preprocessing import MinMaxScaler
    import matplotlib.pyplot as plt
    import datetime
    
    # Проверка доступности GPU
    print("Наличие GPU: ", "Да" if tf.config.list_physical_devices('GPU') else "Нет")
    
    # Параметры
    DATA_FILE = 'bitcoin_data.csv'
    TICKER = 'BTC-USD'
    INTERVAL = '1h'
    LOOKBACK = 60  # Количество предыдущих часов для предсказания
    EPOCHS = 100
    BATCH_SIZE = 32
    
    # Функция для загрузки и обновления данных
    def load_data():
        if os.path.exists(DATA_FILE):
            df = pd.read_csv(DATA_FILE, index_col='Datetime', parse_dates=True)
            # Получаем последнюю дату
            last_date = df.index[-1]
            # Загружаем новые данные
            new_data = yf.download(tickers=TICKER, period='1d', interval=INTERVAL)
            new_data = new_data[new_data.index > last_date]
            if not new_data.empty:
                df = pd.concat([df, new_data])
                df.to_csv(DATA_FILE)
                print(f"Добавлено {len(new_data)} новых записей.")
            else:
                print("Нет новых данных для добавления.")
        else:
            # Загружаем данные за последний год
            df = yf.download(tickers=TICKER, period='1y', interval=INTERVAL)
            df.to_csv(DATA_FILE)
            print(f"Сохранено {len(df)} записей.")
        return df
    
    # Загрузка данных
    df = load_data()
    
    # Используем цену закрытия
    data = df[['Close']]
    
    # Масштабирование данных
    scaler = MinMaxScaler(feature_range=(0, 1))
    scaled_data = scaler.fit_transform(data)
    
    # Создание набора данных для обучения
    def create_dataset(data, lookback=LOOKBACK):
        X, y = [], []
        for i in range(lookback, len(data)):
            X.append(data[i - lookback:i, 0])
            y.append(data[i, 0])
        return np.array(X), np.array(y)
    
    X, y = create_dataset(scaled_data)
    
    # Разделение на обучающую и тестовую выборки
    split = int(len(X) * 0.8)
    X_train, X_test = X[:split], X[split:]
    y_train, y_test = y[:split], y[split:]
    
    # Преобразование входных данных для LSTM [samples, time_steps, features]
    X_train = X_train.reshape((X_train.shape[0], X_train.shape[1], 1))
    X_test = X_test.reshape((X_test.shape[0], X_test.shape[1], 1))
    
    # Построение модели LSTM
    model = Sequential()
    model.add(LSTM(50, return_sequences=True, input_shape=(X_train.shape[1], 1)))
    model.add(LSTM(50))
    model.add(Dense(1))
    
    model.compile(optimizer='adam', loss='mean_squared_error')
    
    # Колбэки для ранней остановки и сохранения лучшей модели
    es = EarlyStopping(monitor='val_loss', patience=10, restore_best_weights=True)
    mc = ModelCheckpoint('best_model.h5', monitor='val_loss', save_best_only=True)
    
    # Обучение модели
    history = model.fit(
        X_train, y_train,
        epochs=EPOCHS,
        batch_size=BATCH_SIZE,
        validation_split=0.2,
        callbacks=[es, mc],
        verbose=1
    )
    
    # Загрузка лучшей модели
    model.load_weights('best_model.h5')
    
    # Оценка модели
    train_pred = model.predict(X_train)
    test_pred = model.predict(X_test)
    
    # Обратное масштабирование
    train_pred = scaler.inverse_transform(train_pred)
    y_train_inv = scaler.inverse_transform(y_train.reshape(-1, 1))
    test_pred = scaler.inverse_transform(test_pred)
    y_test_inv = scaler.inverse_transform(y_test.reshape(-1, 1))
    
    # Функция для построения графиков
    def plot_predictions(dates, true, pred, title):
        plt.figure(figsize=(12,6))
        plt.plot(dates, true, label='Реальность')
        plt.plot(dates, pred, label='Прогноз')
        plt.title(title)
        plt.xlabel('Время')
        plt.ylabel('Цена BTC-USD')
        plt.legend()
        plt.show()
    
    # График за последний год
    last_year = df.index[-split:]
    plot_predictions(
        last_year,
        y_test_inv.flatten(),
        test_pred.flatten(),
        'Сравнение предсказаний с реальностью за последний год'
    )
    
    # График за последнюю неделю
    last_week = last_year[-168:]  # 168 часов = 7 дней
    plot_predictions(
        last_week.index,
        y_test_inv[-168:].flatten(),
        test_pred[-168:].flatten(),
        'Сравнение предсказаний с реальностью за последнюю неделю'
    )
    
    # График за сутки (половина реальности, половина прогноз)
    half_day = 12  # 12 часов реальных и 12 часов прогнозируемых
    dates_half_day = df.index[-24:]
    true_half = y_test_inv[-24:]
    pred_half = test_pred[-24:]
    combined_pred = np.concatenate((true_half[:half_day], pred_half[half_day:]))
    plot_predictions(
        dates_half_day,
        combined_pred,
        combined_pred,
        'Сутки: половина реальности и половина прогноза'
    )
    
    # Предсказание на следующий час
    last_sequence = scaled_data[-LOOKBACK:]
    last_sequence = last_sequence.reshape((1, LOOKBACK, 1))
    next_pred_scaled = model.predict(last_sequence)
    next_pred = scaler.inverse_transform(next_pred_scaled)
    print(f"Предсказание цены биткоина на следующий час: ${next_pred[0][0]:.2f}")
    
    # Вывод текущего времени
    current_time = datetime.datetime.now()
    print(f"Текущее время: {current_time.strftime('%Y-%m-%d %H:%M:%S')}")
    

    Пояснения:

    1. Установка библиотек: Мы устанавливаем yfinance для получения данных и обновляем TensorFlow до последней версии.

    2. Проверка GPU: Проверяем, доступен ли GPU для ускорения обучения модели.

    3. Загрузка данных:

      • Если файл с данными уже существует, мы загружаем его и добавляем только новые записи.
      • Если файла нет, загружаем данные за последний год и сохраняем их.
    4. Предобработка данных:

      • Используем только цену закрытия.
      • Масштабируем данные с помощью MinMaxScaler для лучшей работы модели.
      • Создаем наборы данных для обучения и тестирования с использованием предыдущих 60 часов для предсказания следующего часа.
    5. Построение модели LSTM:

      • Используем два слоя LSTM с 50 нейронами каждый и слой Dense для вывода.
      • Компилируем модель с оптимизатором Adam и функцией потерь MSE.
    6. Обучение модели:

      • Используем EarlyStopping для остановки обучения, если валидационная ошибка не улучшается.
      • Используем ModelCheckpoint для сохранения лучшей модели.
    7. Оценка модели и визуализация:

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

      • Используем последние 60 часов данных для предсказания следующего часа.
      • Выводим текущее время машины.

    Дополнительные рекомендации:

    • Хранение модели: После обучения хорошо сохранять модель для последующего использования без необходимости повторного обучения.
    • Улучшение модели: Можно попробовать добавить больше слоев, использовать другие типы слоев (например, GRU), или экспериментировать с гиперпараметрами.
    • Регуляризация: Добавление регуляризации (например, Dropout) может помочь избежать переобучения.

    Запуск на Kaggle:

    Чтобы запустить этот скрипт на Kaggle:

    1. Создайте новый Notebook на Kaggle.
    2. Скопируйте приведенный выше код в ячейки Notebook.
    3. Включите использование GPU: В настройках Notebook выберите GPU как аппаратное ускорение.
    4. Запустите все ячейки последовательно.

    Удачи с вашим проектом по предсказанию курса биткоина!

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.