Menghubungkan Amazon Redshift dan RStudio di Amazon SageMaker

Tahun lalu, kami mengumumkan ketersediaan umum RStudio di Amazon SageMaker, lingkungan pengembangan terintegrasi (IDE) RStudio Workbench pertama yang dikelola sepenuhnya di industri di cloud. Anda dapat dengan cepat meluncurkan IDE RStudio yang sudah dikenal dan memanggil sumber daya komputasi yang mendasarinya tanpa mengganggu pekerjaan Anda, sehingga memudahkan untuk membangun solusi pembelajaran mesin (ML) dan analitik dalam skala R.

Banyak pengguna RStudio di SageMaker juga merupakan pengguna Pergeseran Merah Amazon, gudang data paralel besar-besaran berskala petabyte yang terkelola sepenuhnya untuk penyimpanan data dan beban kerja analitik. Itu membuatnya cepat, sederhana, dan hemat biaya untuk menganalisis semua data Anda menggunakan SQL standar dan alat intelijen bisnis (BI) yang ada. Pengguna juga dapat berinteraksi dengan data dengan ODBC, JDBC, atau Amazon Redshift Data API.

Penggunaan RStudio di SageMaker dan Amazon Redshift dapat membantu untuk melakukan analisis secara efisien pada kumpulan data besar di cloud. Namun, bekerja dengan data di cloud dapat menghadirkan tantangan, seperti kebutuhan untuk menghapus silo data organisasi, menjaga keamanan dan kepatuhan, serta mengurangi kerumitan dengan menstandarkan peralatan. AWS menawarkan alat seperti RStudio di SageMaker dan Amazon Redshift untuk membantu mengatasi tantangan ini.

Dalam posting blog ini, kami akan menunjukkan kepada Anda bagaimana menggunakan kedua layanan ini bersama-sama untuk melakukan analisis secara efisien pada kumpulan data besar di cloud sambil mengatasi tantangan yang disebutkan di atas. Blog ini berfokus pada Rstudio pada bahasa Amazon SageMaker, dengan analis bisnis, insinyur data, ilmuwan data, dan semua pengembang yang menggunakan Bahasa R dan Amazon Redshift, sebagai audiens target.

Jika Anda ingin menggunakan pengalaman SageMaker Studio tradisional dengan Amazon Redshift, lihat Menggunakan Amazon Redshift Data API untuk berinteraksi dari notebook Amazon SageMaker Jupyter.

Ikhtisar solusi

Di blog hari ini, kami akan menjalankan langkah-langkah berikut:

1. Mengkloning repositori sampel dengan paket yang diperlukan.
2. Menghubungkan ke Amazon Redshift dengan koneksi ODBC yang aman (ODBC adalah protokol pilihan untuk RStudio).
3. Menjalankan kueri dan tindakan API SageMaker pada data dalam Amazon Redshift Tanpa Server melalui RStudio di SageMaker

Proses ini digambarkan dalam arsitektur solusi berikut:

Panduan solusi

Prasyarat

Sebelum memulai, pastikan Anda memiliki semua persyaratan untuk menyiapkan RStudio di Amazon SageMaker dan Amazon Redshift Tanpa Server, seperti:

Kami akan menggunakan tumpukan CloudFormation untuk menghasilkan infrastruktur yang diperlukan.

Catatan: Jika Anda sudah memiliki domain RStudio dan klaster Amazon Redshift, Anda dapat melewati langkah ini

Meluncurkan tumpukan ini akan membuat sumber daya berikut:

• 3 subnet pribadi
• 1 subnet publik
• 1 gerbang NAT
• Gerbang internet
• Kluster Tanpa Server Amazon Redshift
• Domain SageMaker dengan RStudio
• Profil pengguna SageMaker RStudio
• Peran layanan IAM untuk eksekusi domain SageMaker RStudio
• Peran layanan IAM untuk eksekusi profil pengguna SageMaker RStudio

Templat ini dirancang untuk berfungsi di suatu Wilayah (mis. us-east-1, us-west-2) dengan tiga Availability Zone, RStudio di SageMaker, dan Amazon Redshift Tanpa Server. Pastikan Wilayah Anda memiliki akses ke sumber daya tersebut, atau ubah template yang sesuai.

Tekan Luncurkan Stack tombol untuk membuat tumpukan.

1. pada Buat tumpukan halaman, pilih Selanjutnya.
2. pada Tentukan detail tumpukan halaman, berikan nama untuk tumpukan Anda dan biarkan opsi yang tersisa sebagai default, lalu pilih Selanjutnya.
3. pada Konfigurasikan opsi tumpukan halaman, biarkan opsi sebagai default dan tekan Selanjutnya.
4. pada Halaman ulasan, Pilih

• Saya mengakui bahwa AWS CloudFormation dapat membuat sumber daya IAM dengan nama khusus
• Saya memahami bahwa AWS CloudFormation mungkin memerlukan kemampuan berikut: CAPABILITY_AUTO_EXPANDcentang dan pilih Kirim.

Template akan menghasilkan lima tumpukan.

Setelah status tumpukan CREATE_COMPLETE, buka konsol Amazon Redshift Serverless. Ini adalah kemampuan baru yang membuatnya sangat mudah untuk menjalankan analitik di cloud dengan kinerja tinggi pada skala apa pun. Cukup muat data Anda dan mulai membuat kueri. Tidak perlu mengatur dan mengelola cluster.

Note: Pola yang didemonstrasikan dalam blog ini yang mengintegrasikan Amazon Redshift dan RStudio di Amazon SageMaker akan sama terlepas dari pola penerapan Amazon Redshift (tanpa server atau klaster tradisional).

Memuat data di Amazon Redshift Tanpa Server

Skrip CloudFormation membuat database bernama sagemaker. Mari isi database ini dengan tabel untuk kueri pengguna RStudio. Buat tab editor SQL dan pastikan sagemaker basis data dipilih. Kami akan menggunakan data transaksi kartu kredit sintetis untuk membuat tabel di database kami. Data ini merupakan bagian dari kumpulan data tabel sampel SageMaker s3://sagemaker-sample-files/datasets/tabular/synthetic_credit_card_transactions.

Kami akan menjalankan kueri berikut di editor kueri. Ini akan menghasilkan tiga tabel, kartu, transaksi, dan Pengguna.

CREATE SCHEMA IF NOT EXISTS synthetic;
DROP TABLE IF EXISTS synthetic.transactions;

CREATE TABLE synthetic.transactions(
    user_id INT,
    card_id INT,
    year INT,
    month INT,
    day INT,
    time_stamp TIME,
    amount VARCHAR(100),
    use_chip VARCHAR(100),
    merchant_name VARCHAR(100),
    merchant_city VARCHAR(100),
    merchant_state VARCHAR(100),
    merchant_zip_code VARCHAR(100),
    merchant_category_code INT,
    is_error VARCHAR(100),
    is_fraud VARCHAR(100)
);

COPY synthetic.transactions
FROM 's3://sagemaker-sample-files/datasets/tabular/synthetic_credit_card_transactions/credit_card_transactions-ibm_v2.csv'
IAM_ROLE default
REGION 'us-east-1' 
IGNOREHEADER 1 
CSV;

DROP TABLE IF EXISTS synthetic.cards;

CREATE TABLE synthetic.cards(
    user_id INT,
    card_id INT,
    card_brand VARCHAR(100),
    card_type VARCHAR(100),
    card_number VARCHAR(100),
    expire_date VARCHAR(100),
    cvv INT,
    has_chip VARCHAR(100),
    number_cards_issued INT,
    credit_limit VARCHAR(100),
    account_open_date VARCHAR(100),
    year_pin_last_changed VARCHAR(100),
    is_card_on_dark_web VARCHAR(100)
);

COPY synthetic.cards
FROM 's3://sagemaker-sample-files/datasets/tabular/synthetic_credit_card_transactions/sd254_cards.csv'
IAM_ROLE default
REGION 'us-east-1' 
IGNOREHEADER 1 
CSV;

DROP TABLE IF EXISTS synthetic.users;

CREATE TABLE synthetic.users(
    name VARCHAR(100),
    current_age INT,
    retirement_age INT,
    birth_year INT,
    birth_month INT,
    gender VARCHAR(100),
    address VARCHAR(100),
    apartment VARCHAR(100),
    city VARCHAR(100),
    state VARCHAR(100),
    zip_code INT,
    lattitude VARCHAR(100),
    longitude VARCHAR(100),
    per_capita_income_zip_code VARCHAR(100),
    yearly_income VARCHAR(100),
    total_debt VARCHAR(100),
    fico_score INT,
    number_credit_cards INT
);

COPY synthetic.users
FROM 's3://sagemaker-sample-files/datasets/tabular/synthetic_credit_card_transactions/sd254_users.csv'
IAM_ROLE default
REGION 'us-east-1' 
IGNOREHEADER 1 
CSV;

Anda dapat memvalidasi bahwa kueri berhasil dijalankan dengan melihat tiga tabel di panel sebelah kiri editor kueri.

Setelah semua tabel terisi, navigasikan ke SageMaker RStudio dan mulai sesi baru dengan gambar dasar RSession pada instans ml.m5.xlarge.

Setelah sesi diluncurkan, kami akan menjalankan kode ini untuk membuat koneksi ke database Tanpa Server Amazon Redshift kami.

library(DBI)
library(reticulate)
boto3 <- import('boto3')
client <- boto3$client('redshift-serverless')
workgroup <- unlist(client$list_workgroups())
namespace <- unlist(client$get_namespace(namespaceName=workgroup$workgroups.namespaceName))
creds <- client$get_credentials(dbName=namespace$namespace.dbName,
                                durationSeconds=3600L,
                                workgroupName=workgroup$workgroups.workgroupName)
con <- dbConnect(odbc::odbc(),
                 Driver='redshift',
                 Server=workgroup$workgroups.endpoint.address,
                 Port='5439',
                 Database=namespace$namespace.dbName,
                 UID=creds$dbUser,
                 PWD=creds$dbPassword)

Untuk melihat tabel dalam skema sintetik, Anda harus memberikan akses di Amazon Redshift melalui editor kueri.

GRANT ALL ON SCHEMA synthetic to "IAMR:SageMakerUserExecutionRole";
GRANT ALL ON ALL TABLES IN SCHEMA synthetic to "IAMR:SageMakerUserExecutionRole";

RStudio Koneksi panel harus menunjukkan sagemaker database dengan skema sintetik dan kartu tabel, transaksi, pengguna.

Anda dapat mengklik ikon tabel di samping tabel untuk melihat 1,000 catatan.

Catatan: Kami telah membuat file R Markdown pre-built dengan semua blok kode pre-built yang dapat ditemukan di proyek GitHub repo.

Sekarang mari kita gunakan DBI fungsi paket dbListTables() untuk melihat tabel yang ada.

dbListTables(con)

Gunakan dbGetQuery() untuk meneruskan kueri SQL ke database.

dbGetQuery(con, "select * from synthetic.users limit 100")
dbGetQuery(con, "select * from synthetic.cards limit 100")
dbGetQuery(con, "select * from synthetic.transactions limit 100")

Kami juga bisa menggunakan dbplyr dan dplyr paket untuk mengeksekusi kueri dalam database. Ayo count() berapa banyak transaksi yang ada di tabel transaksi. Tapi pertama-tama, kita perlu menginstal paket-paket ini.

install.packages(c("dplyr", "dbplyr", "crayon"))

Gunakan tbl() berfungsi sambil menentukan skema.

library(dplyr)
library(dbplyr)

users_tbl <- tbl(con, in_schema("synthetic", "users"))
cards_tbl <- tbl(con, in_schema("synthetic", "cards"))
transactions_tbl <- tbl(con, in_schema("synthetic", "transactions"))

Mari kita menghitung jumlah baris untuk setiap tabel.

count(users_tbl)
count(cards_tbl)
count(transactions_tbl)

Jadi kami memiliki 2,000 pengguna; 6,146 kartu; dan 24,386,900 transaksi. Kami juga dapat melihat tabel di konsol.

transactions_tbl

Kita juga bisa melihat apa dplyr kata kerja lakukan di bawah tenda.

show_query(transactions_tbl)

Mari jelajahi secara visual jumlah transaksi per tahun.

transactions_by_year %
  count(year) %>%
  arrange(year) %>%
  collect()

transactions_by_year
install.packages(c('ggplot2', 'vctrs'))
library(ggplot2)
ggplot(transactions_by_year) +
  geom_col(aes(year, as.integer(n))) +
  ylab('transactions') 

Kami juga dapat meringkas data dalam database sebagai berikut:

transactions_tbl %>%
  group_by(is_fraud) %>%
  count()
transactions_tbl %>%
  group_by(merchant_category_code, is_fraud) %>%
  count() %>% 
  arrange(merchant_category_code)

Misalkan kita ingin melihat penipuan menggunakan informasi kartu. Kita hanya perlu menggabungkan tabel dan kemudian mengelompokkannya berdasarkan atribut.

cards_tbl %>%
  left_join(transactions_tbl, by = c("user_id", "card_id")) %>%
  group_by(card_brand, card_type, is_fraud) %>%
  count() %>% 
  arrange(card_brand)

Sekarang mari siapkan dataset yang bisa digunakan untuk machine learning. Mari memfilter data transaksi untuk hanya menyertakan kartu kredit Discover sementara hanya mempertahankan sebagian kolom.

discover_tbl %
  filter(card_brand == 'Discover', card_type == 'Credit') %>%
  left_join(transactions_tbl, by = c("user_id", "card_id")) %>%
  select(user_id, is_fraud, merchant_category_code, use_chip, year, month, day, time_stamp, amount)

Dan sekarang mari kita lakukan pembersihan menggunakan transformasi berikut:

• mengubah is_fraud ke atribut biner
• Hapus string transaksi dari use_chip dan ganti namanya menjadi type
• Gabungkan tahun, bulan, dan hari menjadi objek data
• Hapus $ dari jumlah dan ubah menjadi tipe data numerik

discover_tbl %
  mutate(is_fraud = ifelse(is_fraud == 'Yes', 1, 0),
         type = str_remove(use_chip, 'Transaction'),
         type = str_trim(type),
         type = tolower(type),
         date = paste(year, month, day, sep = '-'),
         date = as.Date(date),
         amount = str_remove(amount, '[$]'),
         amount = as.numeric(amount)) %>%
  select(-use_chip, -year, -month, -day)

Sekarang setelah kami memfilter dan membersihkan kumpulan data kami, kami siap untuk mengumpulkan kumpulan data ini ke dalam RAM lokal.

discover <- collect(discover_tbl)
summary(discover)

Sekarang kami memiliki kumpulan data yang berfungsi untuk mulai membuat fitur dan menyesuaikan model. Kami tidak akan membahas langkah-langkah tersebut di blog ini, tetapi jika Anda ingin mempelajari lebih lanjut tentang membuat model di RStudio di SageMaker, lihat Mengumumkan RStudio Terkelola Sepenuhnya di Amazon SageMaker untuk Ilmuwan Data.

Membersihkan

Untuk membersihkan sumber daya apa pun agar tidak menimbulkan biaya berulang, hapus templat root CloudFormation. Hapus juga semua mount EFS yang dibuat dan semua bucket dan objek S3 yang dibuat.

Kesimpulan

Analisis dan pemodelan data dapat menjadi tantangan saat bekerja dengan kumpulan data besar di cloud. Amazon Redshift adalah gudang data populer yang dapat membantu pengguna melakukan tugas ini. RStudio, salah satu lingkungan pengembangan terintegrasi (IDE) yang paling banyak digunakan untuk analisis data, sering digunakan dengan bahasa R. Dalam postingan blog ini, kami menunjukkan cara menggunakan Amazon Redshift dan RStudio di SageMaker bersama-sama untuk melakukan analisis secara efisien pada kumpulan data besar. Dengan menggunakan RStudio di SageMaker, pengguna dapat memanfaatkan infrastruktur yang dikelola sepenuhnya, kontrol akses, jaringan, dan kapabilitas keamanan SageMaker, sekaligus menyederhanakan integrasi dengan Amazon Redshift. Jika Anda ingin mempelajari lebih lanjut tentang penggunaan kedua alat ini bersama-sama, lihat postingan dan sumber daya blog kami yang lain. Anda juga dapat mencoba menggunakan RStudio di SageMaker dan Amazon Redshift untuk Anda sendiri dan melihat bagaimana mereka dapat membantu Anda dengan analisis data dan tugas pemodelan.

Silakan tambahkan umpan balik Anda ke blog ini, atau buat permintaan tarik di GitHub.

Tentang Penulis

Ryan Garner adalah Ilmuwan Data dengan Layanan Profesional AWS. Dia bersemangat membantu pelanggan AWS menggunakan R untuk memecahkan masalah Ilmu Data dan Pembelajaran Mesin mereka.

Raja Pathak adalah Arsitek Solusi Senior dan Teknolog yang berspesialisasi dalam Layanan Keuangan (Asuransi, Perbankan, Pasar Modal) dan Pembelajaran Mesin. Dia berspesialisasi dalam Pemrosesan Bahasa Alami (NLP), Model Bahasa Besar (LLM), dan proyek infrastruktur dan operasi Pembelajaran Mesin (MLOps).

Aditi Rajnish adalah mahasiswa rekayasa perangkat lunak tahun kedua di University of Waterloo. Minatnya meliputi visi komputer, pemrosesan bahasa alami, dan komputasi tepi. Dia juga bersemangat tentang penjangkauan dan advokasi STEM berbasis komunitas. Di waktu luangnya, dia dapat ditemukan memanjat tebing, bermain piano, atau belajar cara membuat scone yang sempurna.

Saiteja Pudi adalah Arsitek Solusi di AWS, berbasis di Dallas, Tx. Dia telah bersama AWS selama lebih dari 3 tahun, membantu pelanggan mendapatkan potensi sebenarnya dari AWS dengan menjadi penasihat tepercaya mereka. Dia berasal dari latar belakang pengembangan aplikasi, tertarik pada Ilmu Data dan Pembelajaran Mesin.