1. Przegląd
W tym laboratorium użyjesz Vertex AI do utworzenia potoku, który trenuje niestandardowy model Keras w TensorFlow. Następnie użyjemy nowych funkcji dostępnych w Vertex AI Experiments, aby śledzić i porównywać uruchomienia modeli w celu określenia, która kombinacja hiperparametrów zapewnia najlepszą wydajność.
Czego się dowiesz
Poznasz takie zagadnienia jak:
- Trenowanie niestandardowego modelu Keras na potrzeby prognozowania ocen graczy (np. regresji)
- Tworzenie skalowalnych potoków ML za pomocą pakietu Kubeflow Pipelines SDK
- utworzyć i uruchomić 5-etapowy potok, który pobiera dane z Cloud Storage, skaluje je, trenuje model, ocenia go i zapisuje wynikowy model z powrotem w Cloud Storage;
- Korzystaj z Vertex ML Metadata, aby zapisywać artefakty modelu, takie jak modele i wartości modelu.
- Używaj Vertex AI Experiments do porównywania wyników różnych uruchomień potoku.
Całkowity koszt ukończenia tego laboratorium w Google Cloud wynosi około 1 USD.
2. Wprowadzenie do Vertex AI
W tym module wykorzystujemy najnowszą ofertę produktów AI dostępną w Google Cloud. Vertex AI integruje oferty ML w Google Cloud, zapewniając płynne środowisko programistyczne. Wcześniej modele wytrenowane za pomocą AutoML i modele niestandardowe były dostępne w ramach osobnych usług. Nowa oferta łączy je w jeden interfejs API wraz z innymi nowymi usługami. Możesz też przeprowadzić migrację istniejących projektów do Vertex AI.
Vertex AI obejmuje wiele różnych usług, które obsługują kompleksowe przepływy pracy związane z uczeniem maszynowym. W tym laboratorium skupimy się na tych usługach: Eksperymenty, Potoki, ML Metadata i Workbench.
3. Omówienie przypadku użycia
Użyjemy popularnego zbioru danych o piłce nożnej pochodzącego z serii gier wideo FIFA od EA Sports. Zawiera ponad 25 tys. meczów piłkarskich i ponad 10 tys. zawodników z sezonów 2008–2016. Dane zostały wstępnie przetworzone, aby ułatwić Ci rozpoczęcie pracy. Będziesz używać tego zbioru danych w całym module. Znajduje się on teraz w publicznym zasobniku Cloud Storage. Więcej informacji o tym, jak uzyskać dostęp do zbioru danych, podamy w dalszej części tego ćwiczenia. Naszym celem jest przewidywanie ogólnej oceny gracza na podstawie różnych działań w grze, takich jak przechwycenia i kary.
Dlaczego Vertex AI Experiments jest przydatny w nauce o danych?
Nauka o danych ma charakter eksperymentalny – w końcu osoby zajmujące się nią nazywane są naukowcami. Dobrzy specjaliści ds. danych kierują się hipotezami i metodą prób i błędów, aby testować różne hipotezy w nadziei, że kolejne iteracje doprowadzą do powstania wydajniejszego modelu.
Zespoły ds. nauki o danych chętnie przeprowadzają eksperymenty, ale często mają problem z śledzeniem swojej pracy i „tajemniczego składnika”, który odkryły dzięki eksperymentom. Dzieje się tak z kilku powodów:
- Śledzenie zadań trenowania może być uciążliwe, przez co łatwo stracić z oczu, co działa, a co nie.
- Problem ten narasta, gdy spojrzysz na cały zespół ds. analizy danych, ponieważ nie wszyscy jego członkowie mogą śledzić eksperymenty lub udostępniać wyniki innym osobom.
- Zbieranie danych jest czasochłonne, a większość zespołów korzysta z metod ręcznych (np.arkuszy lub dokumentów), które dostarczają niespójnych i niekompletnych informacji.
W skrócie: Vertex AI Experiments wykonuje pracę za Ciebie, ułatwiając śledzenie i porównywanie eksperymentów.
Dlaczego warto korzystać z Vertex AI Experiments w przypadku gier?
Gry od dawna są poligonem doświadczalnym dla uczenia maszynowego i eksperymentów z nim związanych. Gry generują miliardy zdarzeń w czasie rzeczywistym dziennie, ale wykorzystują wszystkie te dane, stosując uczenie maszynowe i eksperymenty z uczeniem maszynowym, aby zwiększać komfort gry, zatrzymywać graczy i oceniać różnych graczy na swojej platformie. Dlatego uznaliśmy, że zbiór danych dotyczący gier będzie dobrze pasował do naszych ogólnych eksperymentów.
4. Konfigurowanie środowiska
Aby wykonać to ćwiczenie, musisz mieć projekt w Google Cloud Platform z włączonymi płatnościami. Aby utworzyć projekt, postępuj zgodnie z instrukcjami.
Krok 1. Włącz interfejs Compute Engine API
Przejdź do Compute Engine i kliknij Włącz, jeśli nie jest jeszcze włączona.
Krok 2. Włącz interfejs Vertex AI API
Otwórz sekcję Vertex AI w konsoli Cloud i kliknij Włącz interfejs Vertex AI API.
Krok 3. Tworzenie instancji Vertex AI Workbench
W sekcji Vertex AI w konsoli Cloud kliknij Workbench:
Włącz interfejs Notebooks API, jeśli nie jest jeszcze włączony.
Po włączeniu kliknij ZARZĄDZANE NOTATNIKI:
Następnie wybierz NOWY NOTEBOOK.
Nadaj notatnikowi nazwę, a potem kliknij Ustawienia zaawansowane.
W sekcji Ustawienia zaawansowane włącz wyłączanie w przypadku bezczynności i ustaw liczbę minut na 60. Oznacza to, że Twój notebook będzie się automatycznie wyłączać, gdy nie jest używany, dzięki czemu nie poniesiesz niepotrzebnych kosztów.
Krok 4. Otwórz notatnik
Po utworzeniu instancji wybierz Otwórz JupyterLab.
Krok 5. Uwierzytelnij (tylko za pierwszym razem)
Przy pierwszym użyciu nowej instancji pojawi się prośba o uwierzytelnienie. Aby to zrobić, postępuj zgodnie z instrukcjami wyświetlanymi w interfejsie.
Krok 6. Wybierz odpowiednie jądro
Usługa zarządzanych notatników udostępnia wiele jąder w jednym interfejsie. Wybierz jądro dla TensorFlow 2 (lokalne).
5. Początkowe kroki konfiguracji na notebooku
Przed utworzeniem potoku musisz wykonać w notatniku szereg dodatkowych czynności, aby skonfigurować środowisko. Obejmują one instalowanie dodatkowych pakietów, ustawianie zmiennych, tworzenie zasobnika Cloud Storage, kopiowanie zbioru danych o grach z publicznego zasobnika na dane oraz importowanie bibliotek i definiowanie dodatkowych stałych.
Krok 1. Zainstaluj dodatkowe pakiety
Musimy zainstalować dodatkowe zależności pakietów, które nie są obecnie zainstalowane w środowisku notatnika. Przykładem jest 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 musisz 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 zdefiniować PROJECT_ID. Jeśli nie znasz swojego Project_ID, możesz uzyskać PROJECT_ID za pomocą 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"}
Chcemy też ustawić zmienną REGION, która jest używana w pozostałej części tego notatnika. Poniżej znajdziesz regiony obsługiwane przez Vertex AI. Zalecamy wybór regionu, który znajduje się najbliżej Ciebie.
- Ameryka Północna i Południowa: us-central1
- Europa: europe-west4
- Azja i Pacyfik: asia-east1
Nie używaj zasobnika obejmującego wiele regionów 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. Ta zmienna służy do unikania konfliktów nazw między użytkownikami w przypadku utworzonych zasobów. Dla każdej sesji instancji tworzysz TIMESTAMP i dołączasz 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 wszystkie dane powiązane z zasobami zbioru danych i modelu są przechowywane w różnych sesjach.
Poniżej podaj nazwę zasobnika Cloud Storage. Nazwy zasobników muszą być globalnie unikalne we wszystkich projektach Google Cloud, w tym w projektach 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 Cloud Storage NIE ISTNIEJE, możesz uruchomić poniższą komórkę, aby go utworzyć.
! 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 dotyczący gier
Jak wspomnieliśmy wcześniej, będziesz korzystać z popularnego zbioru danych o grach pochodzącego z hitowej serii gier wideo EA Sports – FIFA. Wykonaliśmy już wstępne przetwarzanie, więc wystarczy, że skopiujesz zbiór danych z publicznego zasobnika pamięci masowej i przeniesiesz go do utworzonego przez siebie 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 zaimportujemy biblioteki dla Vertex AI, KFP itp.
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
Zdefiniujemy też dodatkowe stałe, do których będziemy się odwoływać w dalszej części notatnika, np. ścieżki 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. Tworzenie potoku
Teraz możemy zacząć zabawę i wykorzystać Vertex AI do utworzenia potoku trenowania. Zainicjujemy pakiet Vertex AI SDK, skonfigurujemy zadanie trenowania jako komponent potoku, utworzymy potok, prześlemy uruchomienia potoku i wykorzystamy pakiet Vertex AI SDK do wyświetlania eksperymentów i monitorowania ich stanu.
Krok 1. Zainicjuj pakiet Vertex AI SDK
Zainicjuj pakiet Vertex AI SDK, 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 trenowania jako komponent potoku
Aby rozpocząć przeprowadzanie eksperymentów, musimy określić zadanie trenowania, definiując je jako komponent potoku. Nasz potok będzie przyjmować dane treningowe i hiperparametry (np. DROPOUT_RATE, LEARNING_RATE, EPOCHS) jako dane wejściowe i zwracać wskaźniki 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. Budowanie naszego potoku
Teraz skonfigurujemy przepływ pracy za pomocą funkcji Domain Specific Language (DSL) dostępnej w KFP i skompilujemy 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
Najtrudniejsza część, czyli skonfigurowanie komponentu i zdefiniowanie potoku, jest już za nami. Możemy przesłać różne przebiegi potoku, które zostały określone 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 skutecznie wprowadzać różne przebiegi 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. Wyświetlanie eksperymentów za pomocą pakietu SDK Vertex AI
Pakiet SDK Vertex AI umożliwia monitorowanie stanu uruchomień potoku. Możesz też użyć go do zwracania parametrów i danych 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)
Aby otrzymywać aktualizacje stanu uruchomień potoku, możesz użyć poniższego kodu.
#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ć konkretne zadania potoku za pomocą symbolu 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 czasu (np. co 60 sekund), aby zobaczyć, jak zmienia się on 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. Określanie najlepszego przebiegu
Świetnie, mamy już wyniki uruchomienia 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 dla każdego uruchomienia potoku. Będzie on wyglądać mniej więcej tak:
Zarówno MAE, jak i RMSE to miary średniego błędu prognozy modelu, więc w większości przypadków pożądana jest niższa wartość obu tych wskaźników. Z danych wyjściowych eksperymentów Vertex AI wynika, że najbardziej udany przebieg w przypadku obu wskaźników to ostatni przebieg z wartością dropout_rate = 0,001, learning_rate = 0,001 i łączną liczbą epochs = 20. Na podstawie tego eksperymentu te parametry modelu będą ostatecznie używane w środowisku produkcyjnym, ponieważ zapewniają najlepszą skuteczność modelu.
To już koniec tego laboratorium!
🎉 Gratulacje! 🎉
Dowiedziałeś się, jak używać Vertex AI do:
- Trenowanie niestandardowego modelu Keras na potrzeby 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 je, trenuje model, ocenia go i zapisuje wynikowy model z powrotem w GCS.
- Korzystaj z Vertex ML Metadata, aby zapisywać artefakty modelu, takie jak modele i wartości modelu.
- Używaj Vertex AI Experiments do porównywania wyników różnych uruchomień potoku.
Więcej informacji o różnych częściach Vertex znajdziesz w dokumentacji.
8. Czyszczenie
Aby uniknąć obciążenia konta opłatami, zalecamy usunięcie zasobów utworzonych w ramach tego modułu.
Krok 1. Zatrzymaj lub usuń instancję notatników
Jeśli chcesz nadal korzystać z notatnika utworzonego w tym module, zalecamy wyłączanie go, gdy nie jest używany. W interfejsie Notebooks w konsoli Cloud wybierz notebooka, a następnie kliknij Zatrzymaj. Jeśli chcesz całkowicie usunąć instancję, kliknij Usuń:
Krok 2. Usuń zasobnik Cloud Storage
Aby usunąć zasobnik Storage, w menu nawigacyjnym w konsoli Cloud otwórz Storage, wybierz zasobnik i kliknij Usuń:
