1. Omówienie
W tym module wykorzystasz Vertex AI do utworzenia potoku, który trenuje niestandardowy model Keras w TensorFlow. Następnie użyjemy nowych funkcji dostępnych w Eksperymentach AI z Vertex AI, aby śledzić i porównywać uruchomienia modeli, aby sprawdzić, która kombinacja hiperparametrów zapewnia największą skuteczność.
Czego się nauczysz
Poznasz takie zagadnienia jak:
- Wytrenuj niestandardowy model Keras do prognozowania ocen graczy (np. regresji)
- Tworzenie skalowalnych potoków ML za pomocą pakietu Kubeflow Pipelines SDK
- Utwórz i uruchom 5-etapowy potok, który pozyskuje dane z Cloud Storage, skaluje je, trenuje model, ocenia go i zapisuje z powrotem w Cloud Storage powstały model
- Wykorzystywanie metadanych Vertex ML do zapisywania artefaktów modelu, takich jak modele i wskaźniki modelu
- Wykorzystuj eksperymenty Vertex AI do porównywania wyników różnych uruchomień potoków
Całkowity koszt uruchomienia tego modułu w Google Cloud wynosi około 1 USD.
2. Wprowadzenie do Vertex AI
W tym module wykorzystano najnowszą ofertę usług AI dostępną w Google Cloud. Vertex AI integruje ofertę systemów uczących się z całego Google Cloud, tworząc bezproblemowe środowisko programistyczne. Wcześniej modele wytrenowane z użyciem AutoML i modele niestandardowe były dostępne w oddzielnych usługach. Nowa oferta jest łączona w 1 interfejs API wraz z innymi nowymi usługami. Możesz też przenieść istniejące projekty do Vertex AI.
Vertex AI obejmuje wiele różnych usług, które obsługują kompleksowe przepływy pracy ML. W tym module skupimy się na wymienionych poniżej usługach: Eksperymenty, Potoki, Metadane ML i Workbench.
3. Omówienie przypadku użycia
Wykorzystamy popularny zbiór danych piłkarskich z serwisu EA Sports Seria gier wideo FIFA. Bierze udział w rozgrywkach ponad 25 tysięcy meczów piłki nożnej i ponad 10 tys. zawodników w sezonie 2008–2016. Dane zostały wstępnie przetworzone, co ułatwia pierwsze kroki. W trakcie modułu będziesz używać tego zbioru danych, który można teraz znaleźć w publicznym zasobniku Cloud Storage. Więcej informacji o tym, jak uzyskać dostęp do zbioru danych, podamy w dalszej części szkolenia z programowania. Naszym celem jest przewidywanie ogólnej oceny gracza na podstawie różnych działań w grze, takich jak przechwyty i kary.
Dlaczego eksperymenty Vertex AI są przydatne w badaniu danych?
Badanie danych ma charakter eksperymentalny – w końcu nazywa się je naukowcami. Dobrzy badacze danych opierają się na hipotezie. Metoda prób i błędów pozwala przetestować różne hipotezy z nadzieją, że kolejne iteracje pozwolą uzyskać bardziej wydajny model.
Chociaż zespoły badaczy danych zaangażowały się w eksperymenty, często mają trudności ze śledzeniem swojej pracy i „tajnego sosu”. odkrytych podczas eksperymentów. Dzieje się tak z kilku powodów:
- Śledzenie zadań szkoleniowych może być uciążliwe, ponieważ łatwo jest stracić z oczu to, co się sprawdza, a co nie.
- Problem ten komplikuje się, gdy patrzysz na zespół ds. badania danych, ponieważ nie wszyscy członkowie mogą śledzić eksperymenty lub nawet udostępniać wyniki innym.
- Zbieranie danych jest czasochłonne, a większość zespołów korzysta z ręcznych metod (np. za pomocą arkuszy lub dokumentów), które skutkują niespójnymi i niepełnymi informacjami
tl;dr: Vertex AI Experiments działa za Ciebie, ułatwiając śledzenie i porównywanie eksperymentów.
Dlaczego warto korzystać z Vertex AI Experiments for Gaming?
Do tej pory gry były miejscem eksperymentów z systemami uczącymi się i systemami uczącymi się. Nie tylko generują miliardy zdarzeń w czasie rzeczywistym dziennie, ale również wykorzystują wszystkie te dane, wykorzystując eksperymenty z systemami uczącymi się i systemami uczącymi się, aby poprawić wrażenia z rozgrywki, zatrzymać graczy i ocenić różnych graczy na platformie. Uznaliśmy więc, że zbiór danych o grach dobrze pasuje do naszych ogólnych eksperymentów.
4. Konfigurowanie środowiska
Aby uruchomić to ćwiczenia z programowania, musisz mieć projekt Google Cloud Platform z włączonymi płatnościami. Aby utworzyć projekt, postępuj zgodnie z tymi instrukcjami.
Krok 1. Włącz Compute Engine API
Przejdź do Compute Engine i wybierz opcję Włącz, jeśli nie jest jeszcze włączona.
Krok 2. Włącz interfejs Vertex AI API
Przejdź do sekcji Vertex AI w konsoli Cloud i kliknij Włącz interfejs Vertex AI API.
Krok 3. Utwórz instancję Vertex AI Workbench
W sekcji Vertex AI w konsoli Cloud kliknij Workbench:
Włącz Notebooks API, jeśli nie jest jeszcze włączone.
Po włączeniu kliknij ZARZĄDZANE NOTATKI:
Następnie wybierz NOWY NOTATNIK.
Nadaj notatnikowi nazwę i kliknij Ustawienia zaawansowane.
W sekcji Ustawienia zaawansowane włącz wyłączanie w trybie bezczynności i ustaw liczbę minut na 60. Oznacza to, że Twój notatnik automatycznie wyłączy się, gdy nie będzie używany, aby nie ponosić niepotrzebnych kosztów.
Krok 4. Otwórz notatnik
Po utworzeniu instancji wybierz Otwórz JupyterLab.
Krok 5. Uwierzytelnianie (tylko za pierwszym razem)
Przy pierwszym użyciu nowej instancji zobaczysz prośbę o uwierzytelnienie. W tym celu postępuj zgodnie z instrukcjami w interfejsie.
Krok 6. Wybierz odpowiednie jądro
Zarządzane notatniki mają wiele jąder w jednym interfejsie użytkownika. Wybierz jądro Tensorflow 2 (lokalny).
5. Wstępne kroki konfiguracji w notatniku
Przed utworzeniem potoku musisz wykonać serię dodatkowych czynności, aby skonfigurować środowisko w notatniku. Kroki te obejmują: instalację dodatkowych pakietów, ustawianie zmiennych, utworzenie zasobnika Cloud Storage, skopiowanie zbioru danych gier z publicznego zasobnika na dane, zaimportowanie bibliotek i zdefiniowanie dodatkowych stałych.
Krok 1. Zainstaluj dodatkowe pakiety
Musimy zainstalować dodatkowe zależności pakietu, które nie są obecnie zainstalowane w Twoim środowisku notatników. Przykład obejmuje KFP SDK.
!pip3 install --user --force-reinstall 'google-cloud-aiplatform>=1.15' -q --no-warn-conflicts
!pip3 install --user kfp -q --no-warn-conflicts
Następnie należy ponownie uruchomić jądro notatnika, aby móc używać pobranych pakietów w notatniku.
# Automatically restart kernel after installs
import os
if not os.getenv("IS_TESTING"):
# Automatically restart kernel after installs
import IPython
app = IPython.Application.instance()
app.kernel.do_shutdown(True)
Krok 2: ustaw zmienne
Chcemy określić PROJECT_ID. Jeśli nie znasz tego uprawnienia (Project_ID), możesz pobrać plik PROJECT_ID przy użyciu gcloud.
import os
PROJECT_ID = ""
# Get your Google Cloud project ID from gcloud
if not os.getenv("IS_TESTING"):
shell_output = !gcloud config list --format 'value(core.project)' 2>/dev/null
PROJECT_ID = shell_output[0]
print("Project ID: ", PROJECT_ID)
W przeciwnym razie ustaw PROJECT_ID tutaj.
if PROJECT_ID == "" or PROJECT_ID is None:
PROJECT_ID = "[your-project-id]" # @param {type:"string"}
Musimy też ustawić zmienną REGION, która będzie używana w pozostałej części tego notatnika. Poniżej znajdziesz regiony obsługiwane przez Vertex AI. Zalecamy wybranie najbliższego regionu.
- Ameryka Północna i Południowa: us-central1
- Europa: europe-west4
- Azja i Pacyfik: azja-wschód
Nie używaj zasobnika z wieloma regionami do trenowania w Vertex AI. Nie wszystkie regiony obsługują wszystkie usługi Vertex AI. Dowiedz się więcej o regionach Vertex AI.
#set your region
REGION = "us-central1" # @param {type: "string"}
Na koniec ustawimy zmienną TIMESTAMP. Te zmienne pozwalają uniknąć konfliktów nazw między utworzonymi użytkownikami. Tworzysz identyfikator TIMESTAMP dla każdej sesji instancji i dodajesz go do nazw zasobów tworzonych w tym samouczku.
#set timestamp to avoid collisions between multiple users
from datetime import datetime
TIMESTAMP = datetime.now().strftime("%Y%m%d%H%M%S")
Krok 3. Utwórz zasobnik Cloud Storage
Musisz określić i wykorzystać zasobnik przejściowy Cloud Storage. Zasobnik przejściowy to miejsce, w którym wszystkie dane powiązane ze zbiorem danych i zasobami modelu są przechowywane w różnych sesjach.
Ustaw poniżej nazwę zasobnika Cloud Storage. Nazwy zasobników muszą być globalnie unikalne we wszystkich projektach Google Cloud, również spoza Twojej organizacji.
#set cloud storage bucket
BUCKET_NAME = "[insert bucket name here]" # @param {type:"string"}
BUCKET_URI = f"gs://{BUCKET_NAME}"
Jeśli Twój zasobnik jeszcze NIE istnieje, możesz uruchomić poniższą komórkę, aby utworzyć zasobnik Cloud Storage.
! gsutil mb -l $REGION -p $PROJECT_ID $BUCKET_URI
Następnie możesz sprawdzić dostęp do zasobnika Cloud Storage, uruchamiając poniższą komórkę.
#verify access
! gsutil ls -al $BUCKET_URI
Krok 4. Skopiuj nasz zbiór danych o grach
Jak już wspomnieliśmy, będziesz korzystać z popularnego zbioru danych o grach z przebojowych gier wideo firmy EA Sports, nazwy FIFA. Wcześniej przeprowadziliśmy wstępne przetwarzanie, musisz więc tylko skopiować zbiór danych z publicznego zasobnika na dane i przenieść go do utworzonego przez Ciebie zbioru danych.
# copy the data over to your cloud storage bucket
DATASET_URI = "gs://cloud-samples-data/vertex-ai/structured_data/player_data"
!gsutil cp -r $DATASET_URI $BUCKET_URI
Krok 5. Zaimportuj biblioteki i zdefiniuj dodatkowe stałe
Następnie chcemy zaimportować nasze biblioteki dla Vertex AI, KFP itd.
import logging
import os
import time
logger = logging.getLogger("logger")
logging.basicConfig(level=logging.INFO)
import kfp.v2.compiler as compiler
# Pipeline Experiments
import kfp.v2.dsl as dsl
# Vertex AI
from google.cloud import aiplatform as vertex_ai
from kfp.v2.dsl import Artifact, Input, Metrics, Model, Output, component
from typing import NamedTuple
Zdefiniowane zostaną też dodatkowe stałe, do których będziemy się odwoływać w pozostałej części notatnika, takie jak ścieżki plików do danych treningowych.
#import libraries and define constants
# Experiments
TASK = "regression"
MODEL_TYPE = "tensorflow"
EXPERIMENT_NAME = f"{PROJECT_ID}-{TASK}-{MODEL_TYPE}-{TIMESTAMP}"
# Pipeline
PIPELINE_URI = f"{BUCKET_URI}/pipelines"
TRAIN_URI = f"{BUCKET_URI}/player_data/data.csv"
LABEL_URI = f"{BUCKET_URI}/player_data/labels.csv"
MODEL_URI = f"{BUCKET_URI}/model"
DISPLAY_NAME = "experiments-demo-gaming-data"
BQ_DATASET = "player_data"
BQ_LOCATION = "US"
VIEW_NAME = 'dataset_test'
PIPELINE_JSON_PKG_PATH = "experiments_demo_gaming_data.json"
PIPELINE_ROOT = f"gs://{BUCKET_URI}/pipeline_root"
6. Zbudujmy potok
Teraz zabawa może się zacząć – możemy zacząć korzystać z Vertex AI do tworzenia naszego potoku szkoleń. Zainicjujemy pakiet SDK Vertex AI, skonfigurujemy zadanie treningowe jako komponent potoku, skompilujemy potok, prześlesz uruchomienia potoku i wykorzystamy pakiet SDK Vertex AI do wyświetlania eksperymentów i monitorowania ich stanu.
Krok 1. Zainicjuj pakiet Vertex AI SDK
Zainicjuj pakiet SDK Vertex AI, ustawiając PROJECT_ID i BUCKET_URI.
#initialize vertex AI SDK
vertex_ai.init(project=PROJECT_ID, staging_bucket=BUCKET_URI)
Krok 2. Skonfiguruj zadanie treningowe jako komponent potoku
Aby rozpocząć eksperymenty, musimy określić zadanie treningowe, definiując je jako komponent potoku. Nasz potok pobierze dane treningowe i hiperparametry (np. DROPOUT_RATE, LEARNING_RATE, EPOCHS) jako danych wejściowych i wyjściowych modelu wyjściowego (np. MAE i RMSE) i artefakt modelu.
@component(
packages_to_install=[
"numpy==1.21.0",
"pandas==1.3.5",
"scikit-learn==1.0.2",
"tensorflow==2.9.0",
]
)
def custom_trainer(
train_uri: str,
label_uri: str,
dropout_rate: float,
learning_rate: float,
epochs: int,
model_uri: str,
metrics: Output[Metrics],
model_metadata: Output[Model],
):
# import libraries
import logging
import uuid
from pathlib import Path as path
import pandas as pd
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.layers import Dropout
from tensorflow.keras.metrics import Metric
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_absolute_error
import numpy as np
from math import sqrt
import os
import tempfile
# set variables and use gcsfuse to update prefixes
gs_prefix = "gs://"
gcsfuse_prefix = "/gcs/"
train_path = train_uri.replace(gs_prefix, gcsfuse_prefix)
label_path = label_uri.replace(gs_prefix, gcsfuse_prefix)
model_path = model_uri.replace(gs_prefix, gcsfuse_prefix)
def get_logger():
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
handler.setFormatter(
logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
)
logger.addHandler(handler)
return logger
def get_data(
train_path: str,
label_path: str
) -> (pd.DataFrame):
#load data into pandas dataframe
data_0 = pd.read_csv(train_path)
labels_0 = pd.read_csv(label_path)
#drop unnecessary leading columns
data = data_0.drop('Unnamed: 0', axis=1)
labels = labels_0.drop('Unnamed: 0', axis=1)
#save as numpy array for reshaping of data
labels = labels.values
data = data.values
# Split the data
labels = labels.reshape((labels.size,))
train_data, test_data, train_labels, test_labels = train_test_split(data, labels, test_size=0.2, shuffle=True, random_state=7)
#Convert data back to pandas dataframe for scaling
train_data = pd.DataFrame(train_data)
test_data = pd.DataFrame(test_data)
train_labels = pd.DataFrame(train_labels)
test_labels = pd.DataFrame(test_labels)
#Scale and normalize the training dataset
scaler = StandardScaler()
scaler.fit(train_data)
train_data = pd.DataFrame(scaler.transform(train_data), index=train_data.index, columns=train_data.columns)
test_data = pd.DataFrame(scaler.transform(test_data), index=test_data.index, columns=test_data.columns)
return train_data,train_labels, test_data, test_labels
""" Train your Keras model passing in the training data and values for learning rate, dropout rate,and the number of epochs """
def train_model(
learning_rate: float,
dropout_rate: float,
epochs: float,
train_data: pd.DataFrame,
train_labels: pd.DataFrame):
# Train tensorflow model
param = {"learning_rate": learning_rate, "dropout_rate": dropout_rate, "epochs": epochs}
model = Sequential()
model.add(Dense(500, input_dim=train_data.shape[1], activation= "relu"))
model.add(Dropout(param['dropout_rate']))
model.add(Dense(100, activation= "relu"))
model.add(Dense(50, activation= "relu"))
model.add(Dense(1))
model.compile(
tf.keras.optimizers.Adam(learning_rate= param['learning_rate']),
loss='mse',
metrics=[tf.keras.metrics.RootMeanSquaredError(),tf.keras.metrics.MeanAbsoluteError()])
model.fit(train_data, train_labels, epochs= param['epochs'])
return model
# Get Predictions
def get_predictions(model, test_data):
dtest = pd.DataFrame(test_data)
pred = model.predict(dtest)
return pred
# Evaluate predictions with MAE
def evaluate_model_mae(pred, test_labels):
mae = mean_absolute_error(test_labels, pred)
return mae
# Evaluate predictions with RMSE
def evaluate_model_rmse(pred, test_labels):
rmse = np.sqrt(np.mean((test_labels - pred)**2))
return rmse
#Save your trained model in GCS
def save_model(model, model_path):
model_id = str(uuid.uuid1())
model_path = f"{model_path}/{model_id}"
path(model_path).parent.mkdir(parents=True, exist_ok=True)
model.save(model_path + '/model_tensorflow')
# Main ----------------------------------------------
train_data, train_labels, test_data, test_labels = get_data(train_path, label_path)
model = train_model(learning_rate, dropout_rate, epochs, train_data,train_labels )
pred = get_predictions(model, test_data)
mae = evaluate_model_mae(pred, test_labels)
rmse = evaluate_model_rmse(pred, test_labels)
save_model(model, model_path)
# Metadata ------------------------------------------
#convert numpy array to pandas series
mae = pd.Series(mae)
rmse = pd.Series(rmse)
#log metrics and model artifacts with ML Metadata. Save metrics as a list.
metrics.log_metric("mae", mae.to_list())
metrics.log_metric("rmse", rmse.to_list())
model_metadata.uri = model_uri
Krok 3. Zbuduj potok
Teraz skonfigurujemy przepływ pracy za pomocą usługi Domain Specific Language (DSL) dostępnej w KFP i skompilujemy nasz potok do pliku JSON.
# define our workflow
@dsl.pipeline(name="gaming-custom-training-pipeline")
def pipeline(
train_uri: str,
label_uri: str,
dropout_rate: float,
learning_rate: float,
epochs: int,
model_uri: str,
):
custom_trainer(
train_uri,label_uri, dropout_rate,learning_rate,epochs, model_uri
)
#compile our pipeline
compiler.Compiler().compile(pipeline_func=pipeline, package_path="gaming_pipeline.json")
Krok 4. Prześlij uruchomienia potoku
Wymagana jest ciężka praca związana z konfiguracją komponentu i zdefiniowaniem procesu sprzedaży. Jesteśmy gotowi do przesłania różnych uruchomień potoku, które określiliśmy powyżej. W tym celu musimy w następujący sposób zdefiniować wartości naszych różnych hiperparametrów:
runs = [
{"dropout_rate": 0.001, "learning_rate": 0.001,"epochs": 20},
{"dropout_rate": 0.002, "learning_rate": 0.002,"epochs": 25},
{"dropout_rate": 0.003, "learning_rate": 0.003,"epochs": 30},
{"dropout_rate": 0.004, "learning_rate": 0.004,"epochs": 35},
{"dropout_rate": 0.005, "learning_rate": 0.005,"epochs": 40},
]
Gdy już zdefiniujesz hiperparametry, możemy wykorzystać for loop do skutecznego przesyłania danych w różnych uruchomieniach potoku:
for i, run in enumerate(runs):
job = vertex_ai.PipelineJob(
display_name=f"{EXPERIMENT_NAME}-pipeline-run-{i}",
template_path="gaming_pipeline.json",
pipeline_root=PIPELINE_URI,
parameter_values={
"train_uri": TRAIN_URI,
"label_uri": LABEL_URI,
"model_uri": MODEL_URI,
**run,
},
)
job.submit(experiment=EXPERIMENT_NAME)
Krok 5. Użyj pakietu SDK Vertex AI do wyświetlania eksperymentów
Pakiet Vertex AI SDK umożliwia monitorowanie stanu uruchomień potoków. Możesz też użyć go do zwrócenia parametrów i wskaźników uruchomień potoku w eksperymencie Vertex AI. Aby wyświetlić parametry powiązane z uruchomieniami i ich bieżący stan, użyj tego kodu.
# see state/status of all the pipeline runs
vertex_ai.get_experiment_df(EXPERIMENT_NAME)
Możesz użyć poniższego kodu, aby otrzymywać aktualizacje o stanie uruchomień potoku.
#check on current status
while True:
pipeline_experiments_df = vertex_ai.get_experiment_df(EXPERIMENT_NAME)
if all(
pipeline_state != "COMPLETE" for pipeline_state in pipeline_experiments_df.state
):
print("Pipeline runs are still running...")
if any(
pipeline_state == "FAILED"
for pipeline_state in pipeline_experiments_df.state
):
print("At least one Pipeline run failed")
break
else:
print("Pipeline experiment runs have completed")
break
time.sleep(60)
Możesz też wywoływać określone zadania potoku za pomocą interfejsu run_name.
# Call the pipeline runs based on the experiment run name
pipeline_experiments_df = vertex_ai.get_experiment_df(EXPERIMENT_NAME)
job = vertex_ai.PipelineJob.get(pipeline_experiments_df.run_name[0])
print(job.resource_name)
print(job._dashboard_uri())
Możesz też odświeżać stan uruchomień w ustalonych odstępach (np. co 60 sekund), aby zobaczyć zmianę stanu z RUNNING na FAILED lub COMPLETE.
# wait 60 seconds and view state again
import time
time.sleep(60)
vertex_ai.get_experiment_df(EXPERIMENT_NAME)
7. Wybierz najskuteczniejszy bieg
Świetnie, mamy już wyniki uruchomień potoku. Być może zastanawiasz się, czego możesz się dowiedzieć z wyników tego działania. Dane wyjściowe eksperymentów powinny zawierać 5 wierszy, po 1 na każde uruchomienie potoku. Będzie to wyglądać mniej więcej tak:
Zarówno MAE, jak i RMSE są miernikami średniego błędu prognozy modelu, więc w większości przypadków zalecana jest niższa wartość obu wskaźników. Na podstawie danych wyjściowych z Vertex AI Experiments widzimy, że najbardziej udane uruchomienie w przypadku obu wskaźników to ostatnie uruchomienie z wynikiem dropout_rate o wartości 0,001, learning_rate jeśli to 0,001, a łączna liczba epochs to 20. Na podstawie tego eksperymentu te parametry modelu będą ostatecznie używane w środowisku produkcyjnym, ponieważ zapewni to najlepszą wydajność modelu.
Moduł ukończony.
🎉 Gratulacje! 🎉
Wiesz już, jak używać Vertex AI do:
- Wytrenuj niestandardowy model Keras do prognozowania ocen graczy (np. regresji)
- Tworzenie skalowalnych potoków ML za pomocą pakietu Kubeflow Pipelines SDK
- Utwórz i uruchom 5-etapowy potok, który pozyskuje dane z GCS, skaluje dane, trenuje model, ocenia go i zapisuje z powrotem model powstały w GCS
- Wykorzystywanie metadanych Vertex ML do zapisywania artefaktów modelu, takich jak modele i wskaźniki modelu
- Wykorzystuj eksperymenty Vertex AI do porównywania wyników różnych uruchomień potoków
Więcej informacji o różnych częściach Vertex znajdziesz w dokumentacji.
8. Czyszczenie
Aby uniknąć opłat, zalecamy usunięcie zasobów utworzonych w tym module.
Krok 1. Zatrzymaj lub usuń instancję Notatników
Jeśli chcesz nadal korzystać z notatnika utworzonego w tym module, zalecamy wyłączenie go, gdy nie jest używany. W interfejsie notatników w konsoli Cloud wybierz notatnik, a następnie kliknij Zatrzymaj. Jeśli chcesz całkowicie usunąć instancję, wybierz Usuń:
Krok 2. Usuń zasobnik Cloud Storage
Aby usunąć zasobnik na dane, w menu nawigacyjnym w konsoli Google Cloud otwórz Cloud Storage, wybierz swój zasobnik i kliknij Usuń:
