Ускоренная аналитика данных с Google Cloud и NVIDIA

1. Введение

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

Вы сосредоточитесь на pandas , популярной библиотеке для обработки данных, и узнаете, как ускорить её с помощью библиотеки NVIDIA cuDF . Самое приятное, что вы можете получить это ускорение на GPU, не изменяя существующий код pandas .

Чему вы научитесь

  • Ознакомьтесь с Colab Enterprise в Google Cloud.
  • Настройте среду выполнения Colab с помощью определенных конфигураций графического процессора, центрального процессора и памяти.
  • Ускорьте pandas без изменений кода с помощью NVIDIA cuDF .
  • Профилируйте свой код, чтобы выявить и оптимизировать узкие места производительности.

2. Зачем ускорять обработку данных?

Правило 80/20: почему подготовка данных занимает так много времени

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

К счастью, вы можете ускорить работу популярных библиотек с открытым исходным кодом, таких как pandas, Apache Spark и Polars, на видеокартах NVIDIA с помощью cuDF . Даже при таком ускорении подготовка данных остаётся трудоёмкой, поскольку:

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

3. Выбор среды для ноутбука

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

В Google Cloud доступны два основных варианта управляемых сред для блокнотов: Colab Enterprise и Vertex AI Workbench . Правильный выбор зависит от приоритетов вашего проекта.

Когда использовать Vertex AI Workbench

Выбирайте Vertex AI Workbench, если для вас важны контроль и глубокая настройка . Это идеальный выбор, если вам нужно:

  • Управляйте базовой инфраструктурой и жизненным циклом машины.
  • Используйте пользовательские контейнеры и сетевые конфигурации.
  • Интеграция с конвейерами MLOps и специальными инструментами жизненного цикла.

Когда использовать Colab Enterprise

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

  • Разрабатывайте рабочие процессы для анализа данных, тесно связанные с вашим хранилищем данных. Вы можете открывать блокноты и управлять ими непосредственно в BigQuery Studio .
  • Обучайте модели машинного обучения и интегрируйте их с инструментами MLOps в Vertex AI.
  • Наслаждайтесь гибким и унифицированным интерфейсом. Блокнот Colab Enterprise, созданный в BigQuery, можно открыть и запустить в Vertex AI, и наоборот.

Сегодняшняя лаборатория

В этой лабораторной работе используется Colab Enterprise для ускоренной аналитики данных.

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

4. Настройте шаблон времени выполнения

В Colab Enterprise подключитесь к среде выполнения , основанной на предварительно настроенном шаблоне среды выполнения .

Шаблон времени выполнения — это повторно используемая конфигурация, которая определяет всю среду для вашего блокнота, включая:

  • Тип машины (ЦП, память)
  • Ускоритель (тип и количество графических процессоров)
  • Размер и тип диска
  • Сетевые настройки и политики безопасности
  • Правила автоматического выключения на холостом ходу

Почему шаблоны времени выполнения полезны

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

Создать шаблон времени выполнения

Настройте многоразовый шаблон среды выполнения для лаборатории.

  1. В консоли Google Cloud перейдите в меню навигации > Vertex AI > Colab Enterprise.

Перейдите в Colab Enterprise

  1. В Colab Enterprise нажмите «Шаблоны выполнения» , а затем выберите «Новый шаблон».

Создать новый шаблон времени выполнения

  1. В разделе «Основы выполнения» :
  • Установите отображаемое имя как gpu-template .
  • Укажите предпочитаемый регион .

Имя среды выполнения и конфигурация региона

  1. В разделе «Настройка вычислений» :
  • Установите Тип машины на g2-standard-4 .
  • Измените время отключения при простое на 60 минут.
  1. Нажмите «Создать» , чтобы сохранить шаблон среды выполнения. На странице «Шаблоны среды выполнения» должен появиться новый шаблон.

Установите тип машины шаблона времени выполнения и создайте шаблон

5. Запустите среду выполнения

Когда шаблон готов, вы можете создать новую среду выполнения.

  1. В Colab Enterprise нажмите Runtimes , а затем выберите Create .

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

  1. В разделе «Шаблон среды выполнения» выберите параметр gpu-template . Нажмите «Создать» и дождитесь загрузки среды выполнения.

Загрузите новую среду выполнения

  1. Через несколько минут вы увидите доступную среду выполнения.

Проверяет, доступна ли среда выполнения для использования

6. Настройте блокнот.

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

Импортировать блокнот

  1. В Colab Enterprise нажмите Мои блокноты , а затем нажмите Импорт .

Открывает панель импорта блокнотов.

  1. Выберите переключатель URL и введите следующий URL:

https://github.com/GoogleCloudPlatform/ai-ml-recipes/blob/main/notebooks/analytics/gpu_accelerated_analytics.ipynb

  1. Нажмите «Импорт» . Colab Enterprise скопирует блокнот из GitHub в вашу среду.

Копирует блокнот из публичного репозитория

Подключиться к среде выполнения

  1. Откройте только что импортированный блокнот.
  2. Нажмите стрелку вниз рядом с кнопкой Подключиться .
  3. Выберите Подключиться к среде выполнения .

Открывает панель импорта блокнотов.

  1. Используйте раскрывающийся список и выберите ранее созданную вами среду выполнения.
  2. Нажмите Подключиться .

Открывает панель импорта блокнотов.

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

7. Подготовьте набор данных о такси Нью-Йорка.

В этой лабораторной работе используются данные о поездках Комиссии по такси и лимузинам Нью-Йорка (TLC) .

Набор данных содержит индивидуальные записи о поездках желтых такси в Нью-Йорке и включает в себя такие поля, как:

  • Даты, время и места отправления и возврата
  • Расстояния поездок
  • Детализированные суммы тарифов
  • Количество пассажиров

Загрузить данные

Затем загрузите данные о поездках за весь 2024 год. Данные хранятся в формате файла Parquet.

Следующий блок кода выполняет эти шаги:

  1. Определяет диапазон лет и месяцев для загрузки.
  2. Создает локальный каталог с именем nyc_taxi_data для хранения файлов.
  3. Просматривает каждый месяц, загружает соответствующий файл Parquet, если он еще не существует, и сохраняет его в каталоге.

Запустите этот код в своем блокноте, чтобы собрать данные и сохранить их во время выполнения:

from tqdm import tqdm
import requests
import time
import os

YEAR = 2024
DATA_DIR = "nyc_taxi_data"

os.makedirs(DATA_DIR, exist_ok=True)
print(f"Checking/Downloading files for {YEAR}...")


for month in tqdm(range(1, 13), unit="file"):
    
    # Define standardized filename for both local path and URL
    file_name = f"yellow_tripdata_{YEAR}-{month:02d}.parquet"
    local_path = os.path.join(DATA_DIR, file_name)
    url = f"https://d37ci6vzurychx.cloudfront.net/trip-data/{file_name}"

    if not os.path.exists(local_path):
        try:
            with requests.get(url, stream=True) as response:
                response.raise_for_status()
                with open(local_path, 'wb') as f:
                    for chunk in response.iter_content(chunk_size=8192):
                        f.write(chunk)
            time.sleep(1)
        except requests.exceptions.HTTPError as e:

            print(f"\nSkipping {file_name}: {e}")

            if os.path.exists(local_path):
                os.remove(local_path)

print("\nDownload complete.")

8. Изучите данные о поездках на такси.

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

Загрузить данные за один месяц

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

import pandas as pd
import glob

# Load the last month of the downloaded data
df = pd.read_parquet("nyc_taxi_data/yellow_tripdata_2024-12.parquet")
df.head()

Получить сводную статистику

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

df.describe().round(2)

Отображает сводную статистику

Изучите качество данных

Вывод функции .describe() сразу же выявляет проблему. Обратите внимание, что min значение для tpep_pickup_datetime и tpep_dropoff_datetime приходится на 2008 год, что нелогично для набора данных за 2024 год.

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

# Sort by the dropoff datetime to see the oldest records
df.sort_values("tpep_pickup_datetime").head()

Визуализация распределения данных

Затем вы можете построить гистограммы числовых столбцов для визуализации их распределений. Это поможет вам понять разброс и асимметрию таких признаков, как trip_distance и fare_amount . Функция .hist() — это быстрый способ построить гистограммы для всех числовых столбцов в DataFrame.

_ = df.hist(figsize=(20, 20))

Наконец, сгенерируйте матрицу рассеяния для визуализации взаимосвязей между несколькими ключевыми столбцами. Поскольку построение графика по миллионам точек занимает много времени и может скрыть закономерности, используйте .sample() для построения графика на основе случайной выборки из 100 000 строк.

_ = pd.plotting.scatter_matrix(
    df[['passenger_count', 'trip_distance', 'tip_amount', 'total_amount']].sample(100_000),
    diagonal="kde",
    figsize=(15, 15)
)

9. Зачем использовать формат файла Parquet?

Набор данных о такси Нью-Йорка представлен в формате Apache Parquet . Это осознанный выбор для крупномасштабной аналитики. Parquet обладает рядом преимуществ по сравнению с такими форматами файлов, как CSV:

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

Изучите особенности паркета

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

Проверяйте метаданные без загрузки полного набора данных

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

from pyarrow.parquet import ParquetFile
import pyarrow as pa

# Open one of the downloaded files
pf = ParquetFile('nyc_taxi_data/yellow_tripdata_2024-12.parquet')

# Print the schema
print("File Schema:")
print(pf.schema)

# Print the file metadata
print("\nFile Metadata:")
print(pf.metadata)

Читайте только те столбцы, которые вам нужны

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

import pandas as pd

# Read only four specific columns from the Parquet file
df_subset = pd.read_parquet(
    'nyc_taxi_data/yellow_tripdata_2024-12.parquet',
    columns=['passenger_count', 'trip_distance', 'tip_amount', 'total_amount']
)

df_subset.head()

10. Ускорьте Pandas с помощью NVIDIA cuDF

NVIDIA CUDA для DataFrames (cuDF) — это библиотека с открытым исходным кодом и ускорением на GPU, которая позволяет взаимодействовать с DataFrames. cuDF позволяет выполнять стандартные операции с данными, такие как фильтрация, объединение и группировка, на GPU с массовым параллелизмом.

Ключевая функция, которую вы используете в этой лабораторной работе, — режим ускорителя cudf.pandas . При его включении ваш стандартный код pandas автоматически перенаправляется на использование ядер cuDF , работающих на GPU, без необходимости вносить какие-либо изменения в код.

Включить ускорение графического процессора

Чтобы использовать NVIDIA cuDF в ноутбуке Colab Enterprise, необходимо загрузить его волшебное расширение перед импортом pandas .

Сначала проверьте стандартную библиотеку pandas . Обратите внимание, что в выводе указан путь к установленной по умолчанию библиотеке pandas .

import pandas as pd
pd # Note the output for the standard pandas library

Теперь загрузите расширение cudf.pandas и снова импортируйте pandas . Посмотрите, как изменится вывод модуля pd — это подтверждает, что версия с графическим ускорением теперь активна. 

%load_ext cudf.pandas
import pandas as pd
pd # Note the new output, indicating cudf.pandas is active

Другие способы включения cudf.pandas

Хотя магическая команда ( %load_ext ) является самым простым методом в блокноте, вы также можете включить ускоритель в других средах:

  • В скриптах Python: вызовите import cudf.pandas и cudf.pandas.install() перед импортом pandas .
  • В средах, отличных от блокнота: запустите свой скрипт с помощью python -m cudf.pandas your_script.py .

11. Сравните производительность центрального и графического процессоров

А теперь самая важная часть: сравнение производительности стандартной pandas на CPU с cudf.pandas на GPU.

Чтобы обеспечить абсолютно справедливую нагрузку на процессор, необходимо сначала сбросить среду выполнения Colab. Это удалит все графические ускорители, которые вы могли включить в предыдущих разделах. Вы можете перезапустить среду выполнения, выполнив следующую ячейку или выбрав «Перезапустить сеанс» в меню «Среда выполнения» . 

import IPython

IPython.Application.instance().kernel.do_shutdown(True)

Определите аналитический конвейер

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

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

def run_analytics_pipeline(pd_module):
    """Loads, sorts, and summarizes data using the provided pandas module."""
    timings = {}

    # 1. Load all 2024 Parquet files from the directory
    t0 = time.time()
    df = pd_module.concat(
        [pd_module.read_parquet(f) for f in glob.glob("nyc_taxi_data/*_2024*.parquet")],
        ignore_index=True
    )
    timings["load"] = time.time() - t0

    # 2. Sort the data by multiple columns
    t0 = time.time()
    df = df.sort_values(
        ['tpep_pickup_datetime', 'trip_distance', 'passenger_count'],
        ascending=[False, True, False]
    )
    timings["sort"] = time.time() - t0

    # 3. Perform a groupby and aggregation
    t0 = time.time()
    df['tpep_pickup_datetime'] = pd_module.to_datetime(df['tpep_pickup_datetime'])
    _ = (
        df.loc[df.tpep_pickup_datetime > '2024-11-01']
          .groupby(['VendorID', 'tpep_pickup_datetime'])
          [['passenger_count', 'fare_amount']]
          .agg(['min', 'mean', 'max'])
    )
    timings["summarize"] = time.time() - t0

    return timings

Запустить сравнение

Сначала вы запустите конвейер с помощью стандартного pandas на центральном процессоре. Затем включите cudf.pandas и снова запустите его на графическом процессоре. 

# --- Run on CPU ---
print("Running analytics pipeline on CPU...")
# Ensure we are using standard pandas
import pandas as pd
assert "cudf" not in str(pd), "Error: cuDF is still active. Please restart the kernel."

cpu_times = run_analytics_pipeline(pd)
print(f"CPU times: {cpu_times}")

# --- Run on GPU ---
print("\nEnabling cudf.pandas and running on GPU...")
# Load the extension
%load_ext cudf.pandas
import pandas as gpu_pd

gpu_times = run_analytics_pipeline(gpu_pd)
print(f"GPU times: {gpu_times}")

Визуализируйте результаты

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

# Create a DataFrame for plotting
results_df = pd.DataFrame([cpu_times, gpu_times], index=["CPU", "GPU"]).T
total_cpu_time = results_df['CPU'].sum()
total_gpu_time = results_df['GPU'].sum()
speedup = total_cpu_time / total_gpu_time

print("--- Performance Results ---")
print(results_df)
print(f"\nTotal CPU Time: {total_cpu_time:.2f} seconds")
print(f"Total GPU Time: {total_gpu_time:.2f} seconds")
print(f"Overall Speedup: {speedup:.2f}x")

# Plot the results
fig, ax = plt.subplots(figsize=(10, 6))
results_df.plot(kind='bar', ax=ax, color={"CPU": "tab:blue", "GPU": "tab:green"})

ax.set_ylabel("Time (seconds)")
ax.set_title(f"CPU vs. GPU Runtimes (Overall Speedup: {speedup:.2f}x)", fontsize=14)
ax.tick_params(axis='x', rotation=0)

# Add numerical labels to the bars
for container in ax.containers:
    ax.bar_label(container, fmt="%.2f", padding=3)

plt.tight_layout()
plt.show()

Примеры результатов:

Отображает производительность центрального процессора и графического процессора

Графический процессор обеспечивает явный прирост скорости относительно центрального процессора.

12. Профилируйте свой код, чтобы найти узкие места

Даже при использовании графического ускорения некоторые операции pandas могут отвлекаться на центральный процессор, если они ещё не поддерживаются cuDF . Эти «откаты ЦП» могут стать узким местом в производительности.

Чтобы помочь вам определить эти области, cudf.pandas включает в себя два встроенных профилировщика. С их помощью вы можете точно определить, какие части кода выполняются на графическом процессоре, а какие — на центральном.

  • %%cudf.pandas.profile : используйте этот файл для общего обзора кода по функциям. Он идеально подходит для быстрого обзора того, какие операции выполняются на каком устройстве.
  • %%cudf.pandas.line_profile : используйте этот инструмент для детального построчного анализа. Это лучший инструмент для точного определения строк кода, которые вызывают откат к процессору.

Используйте эти профилировщики как «магию ячеек» в верхней части ячейки блокнота.

Профилирование на уровне функций с помощью %%cudf.pandas.profile

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

%load_ext cudf.pandas
import pandas as pd
import glob

pd.DataFrame({"a": [1]})

Убедившись, что cudf.pandas активен, вы можете запустить профиль. 

%%cudf.pandas.profile

df = pd.concat([pd.read_parquet(f) for f in glob.glob("nyc_taxi_data/*2024*.parquet")], ignore_index=True)

df = df.sort_values(['tpep_pickup_datetime', 'trip_distance', 'passenger_count'], ascending=[False, True, False])

summary = (
    df
        .loc[(df.tpep_pickup_datetime > '2024-11-01')]
        .groupby(['VendorID','tpep_pickup_datetime'])
        [['passenger_count', 'fare_amount']]
        .agg(['min', 'mean', 'max'])
)

Отображает информацию о профилировании Pandas

Построчное профилирование с помощью %%cudf.pandas.line_profile

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

%%cudf.pandas.line_profile

df = pd.concat([pd.read_parquet(f) for f in glob.glob("nyc_taxi_data/*2024*.parquet")], ignore_index=True)

df = df.sort_values(['tpep_pickup_datetime', 'trip_distance', 'passenger_count'], ascending=[False, True, False])

summary = (
    df
        .loc[(df.tpep_pickup_datetime > '2024-11-01')]
        .groupby(['VendorID','tpep_pickup_datetime'])
        [['passenger_count', 'fare_amount']]
        .agg(['min', 'mean', 'max'])
)

Отображает информацию о профилировании Pandas (по строкам)

Профилирование из командной строки

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

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

  • python -m cudf.pandas --profile your_script.py
  • python -m cudf.pandas --line_profile your_script.py

13. Интеграция с облачным хранилищем Google

Google Cloud Storage (GCS) — это масштабируемое и надёжное хранилище объектов. При использовании Colab Enterprise GCS — отличное место для хранения наборов данных, контрольных точек моделей и других артефактов.

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

Создайте контейнер GCS

Сначала создайте новый контейнер GCS. Имена контейнеров GCS глобально уникальны, поэтому добавьте к его имени UUID. 

from google.cloud import storage
import uuid

unique_suffix = uuid.uuid4().hex[:12]
bucket_name = f'nyc-taxi-codelab-{unique_suffix}'
project_id = storage.Client().project

client = storage.Client()

try:
    bucket = client.create_bucket(bucket_name)
    print(f"Successfully created bucket: gs://{bucket.name}")
except Exception as e:
    print(f"Bucket creation failed. You may already own it or the name is taken: {e}")

Записывать данные непосредственно в GCS

Теперь сохраните DataFrame непосредственно в новом контейнере GCS. Если переменная df недоступна в предыдущих разделах, код сначала загрузит данные за один месяц. 

%%cudf.pandas.line_profile

# Ensure the DataFrame exists before saving to GCS
if 'df' not in locals():
    print("DataFrame not found, loading a sample file...")
    df = pd.read_parquet('nyc_taxi_data/yellow_tripdata_2024-12.parquet')

print(f"Writing data to gs://{bucket_name}/nyc_taxi_data.parquet...")
df.to_parquet(f"gs://{bucket_name}/nyc_taxi_data.parquet", index=False)
print("Write operation complete.")

Проверьте файл в GCS

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

from IPython.display import Markdown

gcs_url = f"https://console.cloud.google.com/storage/browser/{bucket_name}?project={project_id}"
Markdown(f'**[Click here to view your GCS bucket in the Google Cloud Console]({gcs_url})**')

Считывание данных напрямую из GCS

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

%%cudf.pandas.line_profile

print(f"Reading data from gs://{bucket_name}/nyc_taxi_data.parquet...")
df_from_gcs = pd.read_parquet(f"gs://{bucket_name}/nyc_taxi_data.parquet")

df_from_gcs.head()

14. Уборка

Чтобы избежать непредвиденных расходов на ваш аккаунт Google Cloud, вам необходимо очистить созданные вами ресурсы.

Удалите загруженные вами данные: 

# Permanately delete the GCS bucket
print(f"Deleting GCS bucket: gs://{bucket_name}...")
!gsutil rm -r -f gs://{bucket_name}
print("Bucket deleted.")

# Remove NYC taxi dataset on the Colab runtime
print("Deleting local 'nyc_taxi_data' directory...")
!rm -rf nyc_taxi_data
print("Local files deleted.")

Завершите работу Colab

  • В консоли Google Cloud перейдите на страницу Colab Enterprise Runtimes .
  • В меню «Регион» выберите регион, содержащий вашу среду выполнения.
  • Выберите среду выполнения, которую вы хотите удалить.
  • Нажмите «Удалить» .
  • Нажмите Подтвердить .

Удалить свой блокнот

  • В консоли Google Cloud перейдите на страницу Colab Enterprise My Notebooks .
  • В меню «Регион» выберите регион, в котором находится ваш блокнот.
  • Выберите блокнот, который вы хотите удалить.
  • Нажмите «Удалить» .
  • Нажмите Подтвердить .

15. Поздравления

Поздравляем! Вы успешно ускорили рабочий процесс Pandas Analytics с помощью NVIDIA cuDF на платформе Colab Enterprise. Вы научились настраивать среды выполнения с поддержкой GPU, включать cudf.pandas для ускорения без изменений кода, профилировать код для выявления узких мест и интегрировать его с Google Cloud Storage.

Справочные документы