1. Omówienie
W tym module użyjesz Vertex AI do tworzenia potoku, który trenuje niestandardowy model Keras w TensorFlow. Następnie użyjemy nowej funkcji dostępnej w eksperymentach Vertex AI, aby śledzić i porównywać uruchomienia modelu i określić, która kombinacja hiperparametrów zapewnia najlepszą wydajność.
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
- utworzyć i uruchamiać 5-etapowy potok, który pobiera dane z Cloud Storage, skaluje je, trenuje model, ocenia go i zapisują uzyskany model z powrotem w Cloud Storage.
- Korzystanie z metadanych Vertex ML do zapisywania artefaktów modelu, takich jak modele i dane dotyczące modelu
- Korzystaj z eksperymentów Vertex AI, aby porównywać wyniki różnych uruchomień potoku
Łączny koszt przeprowadzenia tego laboratorium w Google Cloud wynosi około 1 USD.
2. Wprowadzenie do Vertex AI
Ten moduł wykorzystuje 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 za pomocą AutoML i modele niestandardowe były dostępne za pomocą oddzielnych usług. Nowa oferta łączy oba te interfejsy API z innymi nowymi usługami. Możesz też przenieść istniejące projekty do Vertex AI.
Vertex AI zawiera wiele różnych usług, które obsługują kompleksowe przepływy pracy związane z systemami uczącymi się. W tym laboratorium skupimy się na podanych niżej usługach: Experiments, Pipelines, ML Metadata i Workbench.
3. Omówienie zastosowania
Użyjemy zbioru danych o popularnej piłce nożnej pochodzącego z serii gier wideo FIFA firmy EA Sports. Zawiera on ponad 25 tys. meczy piłki nożnej i ponad 10 tys. graczy z sezonów 2008–2016. Dane zostały wstępnie przetworzone, aby ułatwić Ci rozpoczęcie pracy. W trakcie ćwiczeń będziesz korzystać z tego zbioru danych, który jest teraz dostępny w publicznym zasobniku Cloud Storage. Więcej informacji o dostępie do zbioru danych znajdziesz w później części tego ćwiczenia. Naszym celem jest przewidywanie ogólnej oceny gracza na podstawie różnych działań w grze, takich jak przechwyty i kary.
Dlaczego Vertex AI Experiments jest przydatny w przypadku nauk o danych?
Badanie danych ma charakter eksperymentalny – w końcu nazywa się je naukowcami. Dobrzy naukowcy zajmujący się danymi kierują się hipotezami, testując różne hipotezy metodą prób i błędów w nadziei, że kolejne iteracje przyniosą większą wydajność modelu.
Chociaż zespoły ds. analizy danych stosują eksperymenty, często mają problemy z utrzymywaniem kontroli nad swoją pracą i „tajną recepturą”, która została odkryta dzięki eksperymentom. Dzieje się tak z kilku powodów:
- Śledzenie zadań związanych z treningiem może być uciążliwe, przez co łatwo utracić z oczu to, co działa, 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.
- Pozyskiwanie danych jest czasochłonne, a większość zespołów korzysta z metod ręcznych (np.arkuszy kalkulacyjnych lub dokumentów), które powodują, że informacje do analizy są niespójne i niekompletne.
W skrócie: Vertex AI Experiments wykonuje za Ciebie pracę, ułatwiając śledzenie i porównywanie eksperymentów
Dlaczego warto korzystać z Vertex AI Experiments w przypadku gier?
Gry od dawna są polem do eksperymentowania z systemami uczącymi się. Gry generują miliardy zdarzeń w czasie rzeczywistym dziennie, a dodatkowo wykorzystują wszystkie te dane, korzystając z systemów uczących się i eksperymentów z systemami uczącymi się, aby poprawić wrażenia z gry, zatrzymać graczy i ocenić różnych graczy na platformie. Dlatego uznaliśmy, że zbiór danych o grach będzie pasował 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 Włącz, jeśli usługa 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 konsoli Cloud w sekcji Vertex AI kliknij Workbench:
Włącz interfejs Notebooks API, jeśli nie jest jeszcze włączony.
Po włączeniu tej opcji kliknij ZARZĄDZANE NOTATKI:
Następnie wybierz NOWY NOTATNIK.
Nadaj zeszytowi nazwę, a potem kliknij Ustawienia zaawansowane.
W sekcji Ustawienia zaawansowane włącz funkcję wyłączania bezczynności i ustaw liczbę minut na 60. Oznacza to, że notebook automatycznie się wyłączy, gdy nie będzie używany, dzięki czemu nie poniesiesz niepotrzebnych kosztów.
Krok 4. Otwórz notatnik
Po utworzeniu instancji kliknij Otwórz JupyterLab.
Krok 5. Uwierzytelnienie (tylko przy pierwszym logowaniu)
Gdy po raz pierwszy użyjesz nowego wystąpienia, zostaniesz poproszony o uwierzytelnienie. Aby to zrobić, wykonaj czynności wyświetlane 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 (lokalne).
5. Pierwsze kroki konfiguracji w notatniku
Zanim utworzysz przepływ danych, musisz wykonać kilka dodatkowych czynności, aby skonfigurować środowisko w notatniku. Te kroki obejmują: instalowanie dodatkowych pakietów, ustawianie zmiennych, tworzenie zasobnika Cloud Storage, kopiowanie zbioru danych o grach z publicznego zasobnika Cloud Storage oraz importowanie bibliotek i definiowanie dodatkowych stałych.
Krok 1. Zainstaluj dodatkowe pakiety
Musimy zainstalować dodatkowe zależności pakietu, które nie są obecnie zainstalowane w środowisku notebooka. Przykład obejmuje pakiet 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 uruchom ponownie 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 wartości Project_ID, możesz ją uzyskać za pomocą gcloud.PROJECT_ID
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 tutaj PROJECT_ID.
if PROJECT_ID == "" or PROJECT_ID is None:
PROJECT_ID = "[your-project-id]" # @param {type:"string"}
Musimy też ustawić zmienną REGION, która jest używana w pozostałych częściach tego notatnika. Poniżej znajdują się regiony obsługiwane przez Vertex AI. Zalecamy wybranie regionu, który znajduje się najbliżej Ciebie.
- Ameryka: us-central1
- Europa: europe-west4
- Azja i Pacyfik: asia-east1
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 służą do unikania konfliktów nazw między użytkownikami w przypadku utworzonych zasobów. Utwórz TIMESTAMP dla każdej sesji instancji i dodaj ją do nazwy zasobów utworzonych 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 tymczasowy to miejsce, w którym przechowywane są wszystkie dane powiązane ze zbiorem danych i zasobami modelu w różnych sesjach.
Poniżej ustaw nazwę zasobnika Cloud Storage. Nazwy zasobników muszą być globalnie unikalne we wszystkich projektach Google Cloud, w tym tych spoza Twojej organizacji.
#set cloud storage bucket
BUCKET_NAME = "[insert bucket name here]" # @param {type:"string"}
BUCKET_URI = f"gs://{BUCKET_NAME}"
Jeśli zasobnik jeszcze nie istnieje, możesz uruchomić tę komórkę, aby go utworzyć.
! gsutil mb -l $REGION -p $PROJECT_ID $BUCKET_URI
Następnie możesz zweryfikować dostęp do zasobnika Cloud Storage, uruchamiając tę komórkę.
#verify access
! gsutil ls -al $BUCKET_URI
Krok 4. Skopiuj nasz zbiór danych o grach
Jak już wspomnieliśmy, wykorzystasz popularny zbiór danych o grach, pochodzący z uwielbianej gry wideo FIFA firmy EA Sports. Wykonaliśmy wstępną obróbkę danych, więc wystarczy skopiować zbiory danych z publicznego zasobnika pamięci masowej i przesunąć je do utworzonego przez Ciebie zasobnika.
# 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 Vertex AI SDK, ustawiając parametry 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 element potoku
Aby rozpocząć eksperymenty, musimy określić zadanie treningowe jako element potoku. Nasz potok będzie przyjmować dane do trenowania i parametry (np. DROPOUT_RATE, LEARNING_RATE, EPOCHS) jako dane wejściowe i dane wyjściowe modelu (np. MAE i RMSE) oraz 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. Tworzenie rurociągu
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
Najtrudniejsze już za nami: skonfigurowaliśmy komponent i określiliśmy przepływ pracy. Jesteśmy gotowi do przesłania różnych uruchomień potoku, które określiliśmy powyżej. Aby to zrobić, musimy zdefiniować wartości różnych hiperparametrów w ten sposób:
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},
]
Po zdefiniowaniu hiperparametrów możemy użyć for loop, aby podawać dane do różnych przebiegów potoku danych:
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 Vertex AI SDK, aby wyświetlić eksperymenty
Pakiet Vertex AI SDK umożliwia monitorowanie stanu uruchomień potoku. Możesz też użyć go do zwrócenia parametrów i danych uruchomień potoku w eksperymencie Vertex AI. Aby zobaczyć parametry powiązane z Twoimi przebiegami i ich bieżący stan, użyj tego kodu.
# see state/status of all the pipeline runs
vertex_ai.get_experiment_df(EXPERIMENT_NAME)
Aby uzyskać informacje o stanie wykonania ścieżki, możesz użyć kodu poniżej.
#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ć stany przebiegów w określonych odstępach czasu (np. co 60 sekund), aby zobaczyć, jak stany zmieniają się 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 działania potoku. Możesz się zastanawiać, czego możesz się dowiedzieć z wyników. Dane wyjściowe z eksperymentów powinny zawierać 5 wierszy, po jednym 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 zostaną ostatecznie wykorzystane w produkcji, ponieważ zapewniają najlepszą skuteczność modelu.
To już koniec tego modułu.
🎉 Gratulacje! 🎉
Poznałeś/poznałaś już te sposoby korzystania z Vertex AI:
- 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
- Korzystanie z metadanych Vertex ML do zapisywania artefaktów modelu, takich jak modele i dane dotyczące modelu
- Korzystaj z eksperymentów Vertex AI, aby porównywać wyniki różnych uruchomień potoku
Więcej informacji o różnych elementach Vertex znajdziesz w dokumentacji.
8. Czyszczenie
Aby uniknąć opłat, zalecamy usunięcie zasobów utworzonych w ramach tego laboratorium.
Krok 1. Zatrzymaj lub usuń instancję Notebooks
Jeśli chcesz nadal korzystać z notatnika utworzonego w tym laboratorium, zalecamy jego wyłączenie, gdy go nie używasz. W interfejsie Notebooków w konsoli Cloud Console wybierz notebook, a następnie wybierz Zatrzymaj. Jeśli chcesz całkowicie usunąć instancję, kliknij Usuń:
Krok 2. Usuń zasobnik Cloud Storage
Aby usunąć zasobnik Cloud Storage, w menu nawigacyjnym konsoli Cloud przejdź do usługi Storage, wybierz zasobnik i kliknij Usuń:
