Menggunakan pembelajaran mesin Amazon Aurora dengan Aurora My SQL

Dengan menggunakan pembelajaran mesin Amazon Aurora dengan cluster Aurora My SQL DB Anda, Anda dapat menggunakan Amazon Bedrock, Amazon Comprehend, atau Amazon AI, tergantung pada kebutuhan Anda. SageMaker Mereka masing-masing mendukung kasus penggunaan pembelajaran mesin yang berbeda.

Persyaratan untuk menggunakan pembelajaran mesin Aurora dengan Aurora My SQL

AWS Layanan pembelajaran mesin adalah layanan terkelola yang diatur dan dijalankan di lingkungan produksi mereka sendiri. Pembelajaran mesin Aurora mendukung integrasi dengan Amazon Bedrock, Amazon Comprehend, dan AI. SageMaker Sebelum mencoba mengatur cluster Aurora My SQL DB Anda untuk menggunakan pembelajaran mesin Aurora, pastikan Anda memahami persyaratan dan prasyarat berikut.

Wilayah dan ketersediaan versi

Ketersediaan fitur dan dukungan bervariasi di seluruh versi khusus dari setiap mesin basis data Aurora, dan di seluruh Wilayah AWS.

Fitur dan keterbatasan pembelajaran mesin Aurora yang didukung dengan Aurora My SQL

Saat menggunakan SQL Aurora My dengan pembelajaran mesin Aurora, batasan berikut berlaku:

Menyiapkan cluster Aurora My SQL DB Anda untuk menggunakan pembelajaran mesin Aurora

Dalam topik berikut, Anda dapat menemukan prosedur pengaturan terpisah untuk masing-masing layanan machine learning Aurora ini.

Menyiapkan cluster Aurora My SQL DB Anda untuk menggunakan Amazon Bedrock

Pembelajaran mesin Aurora bergantung pada AWS Identity and Access Management (IAM) peran dan kebijakan untuk memungkinkan klaster Aurora My SQL DB Anda mengakses dan menggunakan layanan Amazon Bedrock. Prosedur berikut membuat kebijakan dan peran IAM izin sehingga klaster DB Anda dapat berintegrasi dengan Amazon Bedrock.

Selanjutnya Anda membuat IAM peran yang menggunakan kebijakan izin Amazon Bedrock.

Selanjutnya Anda mengaitkan IAM peran Amazon Bedrock dengan cluster DB Anda.

Anda harus menambahkan IAM peran ini ke parameter grup aws_default_bedrock_role parameter cluster DB kustom yang terkait dengan cluster Aurora My SQL DB Anda. ARN Jika cluster Aurora My SQL DB Anda tidak menggunakan grup parameter cluster DB kustom, Anda perlu membuatnya untuk digunakan dengan cluster Aurora My SQL DB Anda untuk menyelesaikan integrasi. Untuk informasi selengkapnya, lihat Grup parameter cluster DB untuk cluster Amazon Aurora DB.

IAMIntegrasi untuk Amazon Bedrock selesai. Lanjutkan menyiapkan cluster Aurora My SQL DB Anda untuk bekerja dengan Amazon Bedrock oleh. Memberikan akses pengguna basis data ke machine learning Aurora

Menyiapkan cluster Aurora My SQL DB Anda untuk menggunakan Amazon Comprehend

Pembelajaran mesin Aurora bergantung pada AWS Identity and Access Management peran dan kebijakan untuk memungkinkan klaster Aurora My SQL DB Anda mengakses dan menggunakan layanan Amazon Comprehend. Prosedur berikut secara otomatis membuat IAM peran dan kebijakan untuk klaster Anda sehingga dapat menggunakan Amazon Comprehend.

IAMIntegrasi untuk Amazon Comprehend selesai. Lanjutkan menyiapkan klaster Aurora My SQL DB Anda agar berfungsi dengan Amazon Comprehend dengan memberikan akses ke pengguna database yang sesuai.

Menyiapkan cluster Aurora My SQL DB Anda untuk menggunakan AI SageMaker

Prosedur berikut secara otomatis membuat IAM peran dan kebijakan untuk cluster Aurora My SQL DB Anda sehingga dapat menggunakan SageMaker AI. Sebelum mencoba mengikuti prosedur ini, pastikan Anda memiliki titik akhir SageMaker AI yang tersedia sehingga Anda dapat memasukkannya saat diperlukan. Biasanya, ilmuwan data di tim Anda akan melakukan pekerjaan untuk menghasilkan titik akhir yang dapat Anda gunakan dari cluster Aurora SQL My DB Anda. Anda dapat menemukan titik akhir seperti itu di konsol SageMaker AI. Di panel navigasi, buka menu Inferensi dan pilih Titik akhir. Pada gambar berikut, Anda dapat melihat contohnya.

IAMPengaturan sekarang selesai. Lanjutkan menyiapkan cluster Aurora My SQL DB Anda untuk bekerja dengan SageMaker AI dengan memberikan akses ke pengguna database yang sesuai.

Jika Anda ingin menggunakan model SageMaker AI Anda untuk pelatihan daripada menggunakan komponen SageMaker AI pra-bangun, Anda juga perlu menambahkan bucket Amazon S3 ke cluster Aurora SQL My DB Anda, seperti yang diuraikan dalam berikut ini. Menyiapkan cluster Aurora My SQL DB Anda untuk menggunakan Amazon S3 SageMaker untuk AI (Opsional)

Menyiapkan cluster Aurora My SQL DB Anda untuk menggunakan Amazon S3 SageMaker untuk AI (Opsional)

Untuk menggunakan SageMaker AI dengan model Anda sendiri daripada menggunakan komponen pra-bangun yang disediakan oleh SageMaker AI, Anda perlu menyiapkan bucket Amazon S3 untuk digunakan cluster Aurora SQL My DB. Untuk informasi selengkapnya tentang cara membuat bucket Amazon S3, lihat Membuat bucket dalam Panduan Pengguna Amazon Simple Storage Service.

Untuk informasi selengkapnya tentang menggunakan bucket Amazon S3 dengan SageMaker AI, lihat Menentukan Bucket Amazon S3 untuk Mengunggah Kumpulan Data Pelatihan dan Menyimpan Data Output di Panduan Pengembang Amazon AI. SageMaker Untuk mempelajari selengkapnya tentang bekerja dengan SageMaker AI, lihat SageMaker Memulai Instans Notebook Amazon AI di Panduan Pengembang Amazon SageMaker AI.

Memberikan akses pengguna basis data ke machine learning Aurora

Pengguna database harus diberikan izin untuk menjalankan fungsi pembelajaran mesin Aurora. Cara Anda memberikan izin tergantung pada versi My SQL yang Anda gunakan untuk cluster Aurora My SQL DB Anda, sebagaimana diuraikan dalam berikut ini. Bagaimana Anda melakukannya tergantung pada versi My SQL yang digunakan cluster Aurora My SQL DB Anda.

Tabel berikut menunjukkan peran dan hak istimewa yang dibutuhkan pengguna database untuk bekerja dengan fungsi pembelajaran mesin.

Memberikan akses ke fungsi Amazon Bedrock

Untuk memberi pengguna database akses ke fungsi Amazon Bedrock, gunakan SQL pernyataan berikut:

GRANT AWS_BEDROCK_ACCESS TO user@domain-or-ip-address;

Pengguna database juga perlu diberikan EXECUTE izin untuk fungsi yang Anda buat untuk bekerja dengan Amazon Bedrock:

GRANT EXECUTE ON FUNCTION database_name.function_name TO user@domain-or-ip-address;

Terakhir, pengguna database harus mengatur peran mereka keAWS_BEDROCK_ACCESS:

SET ROLE AWS_BEDROCK_ACCESS;

Fungsi Amazon Bedrock sekarang tersedia untuk digunakan.

Memberikan akses ke fungsi Amazon Comprehend

Untuk memberi pengguna database akses ke fungsi Amazon Comprehend, gunakan pernyataan yang sesuai untuk versi Aurora Saya. SQL

Fungsi Amazon Comprehend sekarang tersedia untuk digunakan. Untuk contoh penggunaan, lihat Menggunakan Amazon Comprehend dengan cluster Aurora My DB Anda SQL.

Memberikan akses ke fungsi SageMaker AI

Untuk memberi pengguna database akses ke fungsi SageMaker AI, gunakan pernyataan yang sesuai untuk versi Aurora My SQL Anda.

Pengguna database juga perlu diberikan EXECUTE izin untuk fungsi yang Anda buat untuk bekerja dengan SageMaker AI. Misalkan Anda membuat dua fungsi, db1.anomoly_score dandb2.company_forecasts, untuk memanggil layanan titik akhir SageMaker AI Anda. Anda memberikan hak istimewa eksekusi seperti yang ditunjukkan pada contoh berikut.

GRANT EXECUTE ON FUNCTION db1.anomaly_score TO user1@domain-or-ip-address1;
GRANT EXECUTE ON FUNCTION db2.company_forecasts TO user2@domain-or-ip-address2;

Fungsi SageMaker AI sekarang tersedia untuk digunakan. Untuk contoh penggunaan, lihat Menggunakan SageMaker AI dengan cluster Aurora My SQL DB Anda.

Menggunakan Amazon Bedrock dengan cluster Aurora My DB SQL Anda

Untuk menggunakan Amazon Bedrock, Anda membuat fungsi (UDF) yang ditentukan pengguna di SQL database Aurora My yang memanggil model. Untuk informasi selengkapnya, lihat Model yang didukung di Amazon Bedrock di Panduan Pengguna Amazon Bedrock.

A UDF menggunakan sintaks berikut:

CREATE FUNCTION function_name (argument type)
        [DEFINER = user]
    RETURNS mysql_data_type
    [SQL SECURITY {DEFINER | INVOKER}]
    ALIAS AWS_BEDROCK_INVOKE_MODEL
    MODEL ID 'model_id'
    [CONTENT_TYPE 'content_type']
    [ACCEPT 'content_type']
    [TIMEOUT_MS timeout_in_milliseconds];

Misalnya, berikut ini UDF memanggil model Amazon Titan Text Express:

CREATE FUNCTION invoke_titan (request_body TEXT)
    RETURNS TEXT
    ALIAS AWS_BEDROCK_INVOKE_MODEL
    MODEL ID 'amazon.titan-text-express-v1'
    CONTENT_TYPE 'application/json'
    ACCEPT 'application/json';

Untuk memungkinkan pengguna DB menggunakan fungsi ini, gunakan SQL perintah berikut:

GRANT EXECUTE ON FUNCTION database_name.invoke_titan TO user@domain-or-ip-address;

Kemudian pengguna dapat memanggil invoke_titan seperti fungsi lainnya, seperti yang ditunjukkan pada contoh berikut. Pastikan untuk memformat badan permintaan sesuai dengan model teks Amazon Titan.

CREATE TABLE prompts (request varchar(1024));
INSERT INTO prompts VALUES (
'{
    "inputText": "Generate synthetic data for daily product sales in various categories - include row number, product name, category, date of sale and price. Produce output in JSON format. Count records and ensure there are no more than 5.",
    "textGenerationConfig": {
        "maxTokenCount": 1024,
        "stopSequences": [],
        "temperature":0,
        "topP":1
    }
}');

SELECT invoke_titan(request) FROM prompts;

{"inputTextTokenCount":44,"results":[{"tokenCount":296,"outputText":"
```tabular-data-json
{
    "rows": [
        {
            "Row Number": "1",
            "Product Name": "T-Shirt",
            "Category": "Clothing",
            "Date of Sale": "2024-01-01",
            "Price": "$20"
        },
        {
            "Row Number": "2",
            "Product Name": "Jeans",
            "Category": "Clothing",
            "Date of Sale": "2024-01-02",
            "Price": "$30"
        },
        {
            "Row Number": "3",
            "Product Name": "Hat",
            "Category": "Accessories",
            "Date of Sale": "2024-01-03",
            "Price": "$15"
        },
        {
            "Row Number": "4",
            "Product Name": "Watch",
            "Category": "Accessories",
            "Date of Sale": "2024-01-04",
            "Price": "$40"
        },
        {
            "Row Number": "5",
            "Product Name": "Phone Case",
            "Category": "Accessories",
            "Date of Sale": "2024-01-05",
            "Price": "$25"
        }
    ]
}
```","completionReason":"FINISH"}]}

Untuk model lain yang Anda gunakan, pastikan untuk memformat badan permintaan dengan tepat untuk mereka. Untuk informasi selengkapnya, lihat Parameter inferensi untuk model foundation di Panduan Pengguna Amazon Bedrock.

Menggunakan Amazon Comprehend dengan cluster Aurora My DB Anda SQL

Untuk Aurora My, pembelajaran mesin SQL Aurora menyediakan dua fungsi bawaan berikut untuk bekerja dengan Amazon Comprehend dan data teks Anda. Anda memberikan teks untuk menganalisis (input_data) dan menentukan bahasa (language_code).

Di kedua fungsi (aws_comprehend_detect_sentiment_confidence, aws_comprehend_detect_sentiment), max_batch_size menggunakan nilai default 25 jika tidak ada yang ditentukan. Ukuran Batch harus selalu lebih besar dari 0. Anda dapat menggunakan max_batch_size untuk menyetel performa dari panggilan fungsi Amazon Comprehend. Ukuran batch yang besar memperdagangkan kinerja yang lebih cepat untuk penggunaan memori yang lebih besar di cluster Aurora My SQL DB. Untuk informasi selengkapnya, lihat Pertimbangan kinerja untuk menggunakan pembelajaran mesin Aurora dengan Aurora My SQL.

Untuk informasi selengkapnya tentang parameter dan tipe pengembalian untuk fungsi deteksi sentimen di Amazon Comprehend, lihat DetectSentiment

SELECT feedback AS 'Customer feedback',
    aws_comprehend_detect_sentiment(feedback, 'en') AS Sentiment,
    ROUND(aws_comprehend_detect_sentiment_confidence(feedback, 'en'), 6)
    AS Confidence FROM support
    ORDER BY Confidence DESC;
+----------------------------------------------------------+-----------+------------+
| Customer feedback                                        | Sentiment | Confidence |
+----------------------------------------------------------+-----------+------------+
| Thank you for the excellent customer support!            | POSITIVE  |   0.999771 |
| The latest version of this product stinks!               | NEGATIVE  |   0.999184 |
| Your support team is just awesome! I am blown away.      | POSITIVE  |   0.997774 |
| Your product is too complex, but your support is great.  | MIXED     |   0.957958 |
| Your support tech helped me in fifteen minutes.          | POSITIVE  |   0.949491 |
| My problem was never resolved!                           | NEGATIVE  |   0.920644 |
| When will the new version of this product be released?   | NEUTRAL   |   0.902706 |
| I cannot stand that chatbot.                             | NEGATIVE  |   0.895219 |
| Your support tech talked down to me.                     | NEGATIVE  |   0.868598 |
| It took me way too long to get a real person.            | NEGATIVE  |   0.481805 |
+----------------------------------------------------------+-----------+------------+
 10 rows in set (0.1898 sec)

SELECT AVG(CASE aws_comprehend_detect_sentiment(productTable.document, 'en')
  WHEN 'POSITIVE' THEN 1.0
  WHEN 'NEGATIVE' THEN -1.0
  ELSE 0.0 END) AS avg_sentiment, COUNT(*) AS total
FROM productTable
WHERE productTable.productCode = 1302 AND
    aws_comprehend_detect_sentiment_confidence(productTable.document, 'en') >= 0.80;

Menggunakan SageMaker AI dengan cluster Aurora My SQL DB Anda

Untuk menggunakan fungsionalitas SageMaker AI dari cluster Aurora My SQL DB Anda, Anda perlu membuat fungsi tersimpan yang menyematkan panggilan Anda ke titik akhir SageMaker AI dan fitur inferensinya. Anda melakukannya dengan menggunakan My SQL secara umum dengan cara yang sama seperti yang Anda lakukan untuk tugas pemrosesan lainnya di cluster Aurora My SQL DB Anda. CREATE FUNCTION

Untuk menggunakan model yang diterapkan di SageMaker AI untuk inferensi, Anda membuat fungsi yang ditentukan pengguna menggunakan pernyataan My SQL data definition language (DDL) untuk fungsi yang disimpan. Setiap fungsi yang disimpan mewakili titik akhir SageMaker AI yang menghosting model. Saat Anda menentukan fungsi seperti itu, Anda menentukan parameter input ke model, titik akhir SageMaker AI spesifik yang akan dipanggil, dan jenis pengembalian. Fungsi mengembalikan inferensi yang dihitung oleh titik akhir SageMaker AI setelah menerapkan model ke parameter input.

Semua fungsi tersimpan machine learning Aurora menampilkan tipe numerik atau VARCHAR. Anda dapat menggunakan jenis numerik kecuali BIT. Jenis lainnya, seperti JSON, BLOB, TEXT, dan DATE tidak diizinkan.

Contoh berikut menunjukkan CREATE FUNCTION sintaks untuk bekerja dengan SageMaker AI.

CREATE FUNCTION function_name (
     arg1 type1, 
     arg2 type2, ...)
     [DEFINER = user]
  RETURNS mysql_type
  [SQL SECURITY { DEFINER | INVOKER } ]
  ALIAS AWS_SAGEMAKER_INVOKE_ENDPOINT
  ENDPOINT NAME 'endpoint_name'
  [MAX_BATCH_SIZE max_batch_size];

Ini adalah perpanjangan dari CREATE FUNCTION DDL pernyataan reguler. Dalam CREATE FUNCTION pernyataan yang mendefinisikan fungsi SageMaker AI, Anda tidak menentukan badan fungsi. Alih-alih, Anda menentukan kata kunci ALIAS yang biasanya digunakan oleh badan fungsi. Saat ini, machine learning Aurora hanya mendukung aws_sagemaker_invoke_endpoint untuk sintaksis yang diperluas ini. Anda harus menentukan parameter endpoint_name. Titik akhir SageMaker AI dapat memiliki karakteristik yang berbeda untuk setiap model.

Parameter max_batch_size bersifat opsional. Secara default, ukuran batch maksimum adalah 10.000. Anda dapat menggunakan parameter ini dalam fungsi Anda untuk membatasi jumlah maksimum input yang diproses dalam permintaan batch ke AI. SageMaker max_batch_sizeParameter dapat membantu menghindari kesalahan yang disebabkan oleh input yang terlalu besar, atau membuat SageMaker AI mengembalikan respons lebih cepat. Parameter ini memengaruhi ukuran buffer internal yang digunakan untuk pemrosesan permintaan SageMaker AI. Menentukan nilai yang terlalu besar untuk max_batch_size dapat menyebabkan overhead memori yang besar pada instans DB Anda.

Sebaiknya biarkan pengaturan MANIFEST pada nilai default OFF. Meskipun Anda dapat menggunakan MANIFEST ON opsi ini, beberapa fitur SageMaker AI tidak dapat langsung menggunakan yang CSV diekspor dengan opsi ini. Format manifes tidak kompatibel dengan format manifes yang diharapkan dari SageMaker AI.

Anda membuat fungsi tersimpan terpisah untuk setiap model SageMaker AI Anda. Pemetaan fungsi ke model ini diperlukan karena titik akhir dikaitkan dengan model tertentu, dan setiap model menerima parameter yang berbeda. Menggunakan SQL tipe untuk input model dan tipe keluaran model membantu menghindari kesalahan konversi tipe yang meneruskan data bolak-balik antara AWS layanan. Anda dapat mengontrol siapa yang dapat menerapkan model tersebut. Anda juga dapat mengontrol karakteristik runtime dengan menentukan parameter yang mewakili ukuran batch maksimum.

Saat ini, semua fungsi machine learning Aurora memiliki properti NOT DETERMINISTIC. Jika Anda tidak menentukan properti tersebut secara eksplisit, Aurora menyetel NOT DETERMINISTIC secara otomatis. Persyaratan ini karena model SageMaker AI dapat diubah tanpa pemberitahuan apa pun ke database. Jika itu terjadi, panggilan ke fungsi machine learning Aurora mungkin menampilkan hasil yang berbeda untuk input yang sama dalam satu transaksi.

Anda tidak dapat menggunakan karakteristik CONTAINS SQL, NO SQL, READS SQL DATA, atau MODIFIES SQL DATA dalam pernyataan CREATE FUNCTION Anda.

Berikut ini adalah contoh penggunaan titik akhir SageMaker AI untuk mendeteksi anomali. Ada titik akhir SageMaker random-cut-forest-model AI. Model yang sesuai sudah dilatih oleh algoritma random-cut-forest. Untuk setiap input, model menampilkan skor anomali. Contoh ini menunjukkan poin data yang nilainya lebih besar dari 3 deviasi standar (kira-kira persentil ke-99,9) dari skor rata-rata.

CREATE FUNCTION anomaly_score(value real) returns real
  alias aws_sagemaker_invoke_endpoint endpoint name 'random-cut-forest-model-demo';

set @score_cutoff = (select avg(anomaly_score(value)) + 3 * std(anomaly_score(value)) from nyc_taxi);

select *, anomaly_detection(value) score from nyc_taxi
  where anomaly_detection(value) > @score_cutoff;

Persyaratan set karakter untuk fungsi SageMaker AI yang mengembalikan string

Sebaiknya tentukan kumpulan karakter utf8mb4 sebagai tipe pengembalian untuk fungsi SageMaker AI Anda yang mengembalikan nilai string. Jika itu tidak praktis, gunakan panjang string yang cukup besar agar jenis kembalian dapat menampung nilai yang direpresentasikan dalam kumpulan karakter utf8mb4. Contoh berikut menunjukkan cara mendeklarasikan set karakter utf8mb4 untuk fungsi Anda.

CREATE FUNCTION my_ml_func(...) RETURNS VARCHAR(5) CHARSET utf8mb4 ALIAS ...

Saat ini, setiap fungsi SageMaker AI yang mengembalikan string menggunakan set karakter utf8mb4 untuk nilai yang dikembalikan. Nilai yang dikembalikan menggunakan set karakter ini meskipun fungsi SageMaker AI Anda mendeklarasikan set karakter yang berbeda untuk tipe pengembaliannya secara implisit atau eksplisit. Jika fungsi SageMaker AI Anda mendeklarasikan set karakter yang berbeda untuk nilai yang dikembalikan, data yang dikembalikan mungkin terpotong secara diam-diam jika Anda menyimpannya di kolom tabel yang tidak cukup panjang. Misalnya, kueri dengan klausa DISTINCT membuat tabel sementara. Dengan demikian, hasil fungsi SageMaker AI mungkin terpotong karena cara string ditangani secara internal selama kueri.

Mengekspor data ke Amazon S3 SageMaker untuk pelatihan model AI (Lanjutan)

Kami menyarankan Anda memulai pembelajaran mesin Aurora dan SageMaker AI dengan menggunakan beberapa algoritme yang disediakan, dan bahwa ilmuwan data di tim Anda memberi Anda titik akhir SageMaker AI yang dapat Anda gunakan dengan kode Anda. SQL Berikut ini, Anda dapat menemukan informasi minimal tentang penggunaan bucket Amazon S3 Anda sendiri dengan model SageMaker AI Anda sendiri dan cluster Aurora My DB Anda. SQL

Machine learning terdiri dari dua langkah utama: pelatihan, dan inferensi. Untuk melatih model SageMaker AI, Anda mengekspor data ke bucket Amazon S3. Bucket Amazon S3 digunakan oleh instance notebook Jupyter SageMaker AI untuk melatih model Anda sebelum digunakan. Anda dapat menggunakan SELECT INTO OUTFILE S3 pernyataan untuk menanyakan data dari cluster Aurora My SQL DB dan menyimpannya langsung ke file teks yang disimpan dalam bucket Amazon S3. Kemudian instans notebook menggunakan data dari bucket Amazon S3 untuk pelatihan.

Pembelajaran mesin Aurora memperluas SELECT INTO OUTFILE sintaks yang ada di Aurora SQL My untuk mengekspor data ke format. CSV CSVFile yang dihasilkan dapat langsung dikonsumsi oleh model yang membutuhkan format ini untuk tujuan pelatihan.

SELECT * INTO OUTFILE S3 's3_uri' [FORMAT {CSV|TEXT} [HEADER]] FROM table_name;

Ekstensi mendukung CSV format standar.

Sintaks dan tata bahasa SELECT INTO yang diperluas sekarang adalah sebagai berikut:

INTO OUTFILE S3 's3_uri'
[CHARACTER SET charset_name]
[FORMAT {CSV|TEXT} [HEADER]]
[{FIELDS | COLUMNS}
  [TERMINATED BY 'string']
  [[OPTIONALLY] ENCLOSED BY 'char']
  [ESCAPED BY 'char']
]
[LINES
  [STARTING BY 'string']
  [TERMINATED BY 'string']
]

Pertimbangan kinerja untuk menggunakan pembelajaran mesin Aurora dengan Aurora My SQL

Amazon Bedrock, Amazon Comprehend SageMaker , dan layanan AI melakukan sebagian besar pekerjaan ketika dipanggil oleh fungsi pembelajaran mesin Aurora. Itu berarti Anda dapat menskalakan sumber daya tersebut sesuai kebutuhan, secara mandiri. Untuk cluster Aurora My SQL DB Anda, Anda dapat membuat panggilan fungsi Anda seefisien mungkin. Berikut ini, Anda dapat menemukan beberapa pertimbangan performa yang perlu diperhatikan saat bekerja dengan machine learning Aurora.

Model dan prompt

Performa saat menggunakan Amazon Bedrock sangat bergantung pada model dan prompt yang Anda gunakan. Pilih model dan prompt yang optimal untuk kasus penggunaan Anda.

Cache kueri

Cache SQL kueri Aurora My tidak berfungsi untuk fungsi pembelajaran mesin Aurora. Aurora My SQL tidak menyimpan hasil kueri di cache kueri untuk SQL pernyataan apa pun yang memanggil fungsi pembelajaran mesin Aurora.

Optimalisasi batch untuk panggilan fungsi machine learning Aurora

Aspek performa utama machine learning Aurora yang dapat Anda pengaruhi dari klaster Aurora adalah pengaturan mode batch untuk panggilan ke fungsi tersimpan machine learning Aurora. Fungsi machine learning biasanya membutuhkan overhead yang besar, sehingga tidak praktis untuk memanggil layanan eksternal secara terpisah untuk setiap baris. Machine learning Aurora dapat meminimalkan overhead ini dengan menggabungkan panggilan ke layanan machine learning Aurora eksternal untuk banyak baris ke dalam satu batch. Machine learning Aurora menerima respons untuk semua baris input, dan mengirimkan respons, satu baris dalam satu waktu, ke kueri saat dijalankan. Pengoptimalan ini meningkatkan throughput dan latensi kueri Aurora Anda tanpa mengubah hasil.

Saat Anda membuat fungsi tersimpan Aurora yang terhubung ke titik akhir SageMaker AI, Anda menentukan parameter ukuran batch. Parameter ini memengaruhi berapa banyak baris yang ditransfer untuk setiap panggilan yang mendasarinya ke SageMaker AI. Untuk kueri yang memproses sejumlah besar baris, overhead untuk membuat panggilan SageMaker AI terpisah untuk setiap baris bisa sangat besar. Semakin besar kumpulan data yang diproses oleh prosedur tersimpan, semakin besar Anda dapat membuat ukuran batch.

Jika pengoptimalan mode batch dapat diterapkan ke fungsi SageMaker AI, Anda dapat mengetahuinya dengan memeriksa paket kueri yang dihasilkan oleh EXPLAIN PLAN pernyataan tersebut. Dalam kasus ini, kolom extra dalam rencana eksekusi termasuk Batched machine learning. Contoh berikut menunjukkan panggilan ke fungsi SageMaker AI yang menggunakan mode batch.

mysql> CREATE FUNCTION anomaly_score(val real) returns real alias aws_sagemaker_invoke_endpoint endpoint name 'my-rcf-model-20191126';
Query OK, 0 rows affected (0.01 sec)

mysql> explain select timestamp, value, anomaly_score(value) from nyc_taxi;
+----+-------------+----------+------------+------+---------------+------+---------+------+------+----------+--------------------------+
| id | select_type | table    | partitions | type | possible_keys | key  | key_len | ref  | rows | filtered | Extra                    |
+----+-------------+----------+------------+------+---------------+------+---------+------+------+----------+--------------------------+
|  1 | SIMPLE      | nyc_taxi | NULL       | ALL  | NULL          | NULL | NULL    | NULL |   48 |   100.00 | Batched machine learning |
+----+-------------+----------+------------+------+---------------+------+---------+------+------+----------+--------------------------+
1 row in set, 1 warning (0.01 sec)

Saat Anda memanggil salah satu fungsi Amazon Comprehend default, Anda dapat mengontrol ukuran batch dengan menentukan parameter max_batch_size opsional. Parameter ini membatasi jumlah maksimum nilai input_text yang diproses di setiap batch. Dengan mengirim beberapa item sekaligus, ini mengurangi jumlah perjalanan bolak-balik antara Aurora dan Amazon Comprehend. Membatasi ukuran batch berguna dalam situasi seperti kueri dengan klausa LIMIT. Dengan menggunakan nilai kecil untuk max_batch_size, Anda dapat menghindari permintaan Amazon Comprehend lebih sering daripada Anda memiliki teks input.

Optimalisasi batch untuk mengevaluasi fungsi machine learning Aurora berlaku dalam kasus berikut:

Memantau machine learning Aurora

Anda dapat memantau operasi batch pembelajaran mesin Aurora dengan menanyakan beberapa variabel global, seperti yang ditunjukkan pada contoh berikut.

show status like 'Aurora_ml%';

Anda dapat mengatur ulang variabel status dengan menggunakan pernyataan FLUSH STATUS. Jadi, semua angka mewakili total, rata-rata, dan seterusnya, sejak terakhir kali variabel disetel ulang.

Untuk informasi tentang pemantauan kinerja operasi SageMaker AI yang disebut dari fungsi pembelajaran mesin Aurora, lihat Memantau Amazon SageMaker AI.