Menggunakan machine learning Amazon Aurora dengan Aurora MySQL

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

Persyaratan untuk menggunakan machine learning Aurora dengan Aurora MySQL

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. SageMaker Sebelum mencoba menyiapkan klaster DB Aurora MySQL untuk menggunakan machine learning 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 yang didukung dan batasan machine learning Aurora dengan Aurora MySQL

Saat menggunakan Aurora MySQL dengan pembelajaran mesin Aurora, batasan berikut berlaku:

Menyiapkan klaster DB Aurora MySQL untuk menggunakan machine learning Aurora

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

Menyiapkan cluster DB MySQL Aurora Anda untuk menggunakan Amazon Bedrock

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

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

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

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

Integrasi IAM untuk Amazon Bedrock selesai. Lanjutkan menyiapkan cluster DB MySQL Aurora Anda untuk bekerja dengan Amazon Bedrock oleh. Memberikan akses pengguna basis data ke machine learning Aurora

Menyiapkan klaster DB Aurora MySQL untuk menggunakan Amazon Comprehend

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

Integrasi IAM untuk Amazon Comprehend selesai. Lanjutkan penyiapan klaster DB Aurora MySQL Anda untuk bekerja dengan Amazon Comprehend dengan memberikan akses ke pengguna basis data yang sesuai.

Menyiapkan cluster DB MySQL Aurora Anda untuk digunakan SageMaker

Prosedur berikut secara otomatis membuat peran dan kebijakan IAM untuk cluster Aurora MySQL DB Anda sehingga dapat digunakan. SageMaker Sebelum mencoba mengikuti prosedur ini, pastikan Anda memiliki SageMaker titik akhir 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 klaster DB Aurora MySQL Anda. Anda dapat menemukan titik akhir seperti itu di SageMaker konsol. Di panel navigasi, buka menu Inferensi dan pilih Titik akhir. Pada gambar berikut, Anda dapat melihat contohnya.

Pengaturan IAM sudah selesai. Lanjutkan menyiapkan cluster DB MySQL Aurora Anda untuk bekerja dengan SageMaker dengan memberikan akses ke pengguna database yang sesuai.

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

Menyiapkan cluster DB MySQL Aurora Anda untuk menggunakan Amazon S3 untuk (Opsional) SageMaker

Untuk menggunakan SageMaker model Anda sendiri daripada menggunakan komponen pra-bangun yang disediakan oleh SageMaker, Anda perlu menyiapkan bucket Amazon S3 untuk digunakan oleh cluster DB MySQL Aurora. 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, lihat Menentukan Bucket Amazon S3 untuk Mengunggah Kumpulan Data Pelatihan dan Menyimpan Data Output di Panduan Pengembang Amazon. SageMaker Untuk mempelajari lebih lanjut tentang bekerja dengan SageMaker, lihat Memulai Instans SageMaker Notebook Amazon di Panduan SageMaker Pengembang Amazon.

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 versi MySQL yang Anda gunakan untuk klaster DB Aurora MySQL Anda, seperti yang diuraikan sebagai berikut. Bagaimana Anda melakukannya tergantung versi MySQL yang digunakan klaster DB Aurora MySQL 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 pernyataan SQL 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 basis data akses ke fungsi Amazon Comprehend, gunakan pernyataan yang sesuai untuk versi Aurora MySQL Anda.

Fungsi Amazon Comprehend sekarang tersedia untuk digunakan. Untuk contoh penggunaan, lihat Menggunakan Amazon Comprehend dengan klaster DB Aurora MySQL.

Memberikan akses ke fungsi SageMaker

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

Pengguna database juga perlu diberikan EXECUTE izin untuk fungsi yang Anda buat untuk bekerja dengan SageMaker. Misalkan Anda membuat dua fungsi, db1.anomoly_score dandb2.company_forecasts, untuk memanggil layanan SageMaker endpoint 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;

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

Menggunakan Amazon Bedrock dengan cluster DB MySQL Aurora Anda

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

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, UDF berikut 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 perintah SQL 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 klaster DB Aurora MySQL

Untuk Aurora MySQL, machine learning Aurora menyediakan dua fungsi default 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 mengorbankan performa yang lebih cepat demi penggunaan memori yang lebih besar pada klaster DB Aurora MySQL. Untuk informasi selengkapnya, lihat Pertimbangan performa untuk machine learning Aurora dengan Aurora MySQL.

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 dengan cluster DB MySQL Aurora Anda

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

Untuk menggunakan model yang digunakan SageMaker untuk inferensi, Anda membuat fungsi yang ditentukan pengguna menggunakan pernyataan bahasa definisi data MySQL (DDL) untuk fungsi yang disimpan. Setiap fungsi yang disimpan mewakili SageMaker titik akhir yang menghosting model. Saat Anda mendefinisikan fungsi seperti itu, Anda menentukan parameter input ke model, SageMaker titik akhir spesifik yang akan dipanggil, dan jenis pengembalian. Fungsi mengembalikan inferensi yang dihitung oleh SageMaker titik akhir 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.

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 pernyataan DDL CREATE FUNCTION reguler. Dalam CREATE FUNCTION pernyataan yang mendefinisikan SageMaker fungsi, 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. SageMaker Titik akhir 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. SageMaker max_batch_sizeParameter dapat membantu menghindari kesalahan yang disebabkan oleh input yang terlalu besar, atau untuk membuat SageMaker pengembalian respons lebih cepat. Parameter ini mempengaruhi ukuran buffer internal yang digunakan untuk pemrosesan SageMaker permintaan. 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 SageMaker fitur tidak dapat langsung menggunakan CSV yang diekspor dengan opsi ini. Format manifes tidak kompatibel dengan format manifes yang diharapkan dari SageMaker.

Anda membuat fungsi tersimpan terpisah untuk masing-masing SageMaker model Anda. Pemetaan fungsi ke model ini diperlukan karena titik akhir dikaitkan dengan model tertentu, dan setiap model menerima parameter yang berbeda. Menggunakan tipe SQL untuk input model dan tipe keluaran model membantu menghindari kesalahan konversi tipe yang meneruskan data bolak-balik antara layanan. AWS 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 SageMaker model 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 menggunakan SageMaker titik akhir untuk mendeteksi anomali. Ada SageMaker titik akhirrandom-cut-forest-model. 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 SageMaker fungsi yang mengembalikan string

Sebaiknya tentukan set karakter utf8mb4 sebagai tipe pengembalian untuk SageMaker fungsi 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 SageMaker fungsi yang mengembalikan string menggunakan set karakter utf8mb4 untuk nilai kembali. Nilai yang dikembalikan menggunakan set karakter ini bahkan jika SageMaker fungsi Anda mendeklarasikan set karakter yang berbeda untuk tipe pengembaliannya secara implisit atau eksplisit. Jika SageMaker fungsi 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 SageMaker fungsi mungkin terpotong karena cara string ditangani secara internal selama kueri.

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

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

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

Machine learning Aurora memperluas sintaksis SELECT INTO OUTFILE yang ada di Aurora MySQL untuk mengekspor data ke format CSV. File CSV yang dihasilkan dapat digunakan secara langsung oleh model yang memerlukan format ini untuk tujuan pelatihan.

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

Ekstensi mendukung format CSV 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 performa untuk machine learning Aurora dengan Aurora MySQL

Amazon Bedrock, Amazon Comprehend SageMaker , dan layanan melakukan sebagian besar pekerjaan saat dipanggil oleh fungsi pembelajaran mesin Aurora. Itu berarti Anda dapat menskalakan sumber daya tersebut sesuai kebutuhan, secara mandiri. Untuk klaster DB Aurora MySQL Anda, Anda dapat membuat panggilan fungsi 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 kueri Aurora MySQL tidak berfungsi untuk fungsi machine learning Aurora. Aurora MySQL tidak menyimpan hasil kueri di cache kueri untuk pernyataan SQL apa pun yang memanggil fungsi machine learning 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 SageMaker titik akhir, Anda menentukan parameter ukuran batch. Parameter ini memengaruhi berapa banyak baris yang ditransfer untuk setiap panggilan yang mendasarinya SageMaker. Untuk kueri yang memproses sejumlah besar baris, overhead untuk membuat SageMaker panggilan terpisah untuk setiap baris bisa sangat besar. Semakin besar kumpulan data yang diproses oleh prosedur tersimpan, semakin besar Anda dapat membuat ukuran batch.

Jika optimasi mode batch dapat diterapkan ke suatu SageMaker fungsi, Anda dapat mengetahuinya dengan memeriksa rencana 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 SageMaker fungsi 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 SageMaker operasi yang disebut dari fungsi pembelajaran mesin Aurora, lihat Memantau Amazon. SageMaker