9 công cụ mã nguồn mở đỉnh cao để xây dựng ứng dụng AI thế hệ mới
Trong nhiều năm xây dựng và làm việc với các ứng dụng AI, tôi đã từng sử dụng nhiều công cụ và thư viện bên thứ ba để đơn giản hóa toàn bộ quy trình phát triển. Bài viết này sẽ giới thiệu 9 công cụ vô cùng tiện dụng nhưng ít được biết đến giúp bạn dễ dàng hơn trong công việc. Hãy cùng khám phá nhé!
Đọc thêm: Mã nguồn mở là gì? 5 phần mềm mã nguồn mở ưa chuộng nhất hiện nay
1. Composio - Nền tảng tích hợp và công cụ AI
Hãy tưởng tượng bạn có khả năng xây dựng các tác nhân AI của riêng mình và tích hợp chúng liền mạch vào các công cụ như Discord, Trello, Jira hoặc Slack. Đó chính là Composio!
Nó là một nền tảng mã nguồn mở giúp việc thêm chức năng AI vào các ứng dụng của bạn trở nên dễ dàng và dễ tiếp cận. Cho dù bạn đang tùy chỉnh một tác nhân AI hay cắm nó vào các công cụ yêu thích của mình, Composio đều hỗ trợ bạn.
Một số trường hợp sử dụng của Composio:
- Xây dựng tác nhân lập trình để tối ưu hóa mã hiện có trong kho lưu trữ Github
- Xây dựng bot AI cho các kênh Slack và máy chủ Discord của bạn, có thể tự động tương tác với người dùng và trả lời các câu hỏi của họ.
- Tác nhân AI để cung cấp tóm tắt báo cáo hoặc tài liệu.
Bắt đầu với Composio:
pip install composio-core
Thêm tích hợp GitHub:
composio add github
Composio quản lý xác thực và ủy quyền người dùng cho bạn.
Dưới đây là một ví dụ để tự động gắn sao cho kho lưu trữ GitHub bằng cách sử dụng tích hợp GitHub của Composio:
from openai import OpenAI
from composio_openai import ComposioToolSet, App
openai_client = OpenAI(api_key=OPENAI_API_KEY)
# Initialise the Composio Tool Set
composio_toolset = ComposioToolSet(api_key=COMPOSIO_API_KEY)
## Step 4
# Get GitHub tools that are pre-configured
actions = composio_toolset.get_actions(actions=[Action.GITHUB_ACTIVITY_STAR_REPO_FOR_AUTHENTICATED_USER])
## Step 5
my_task = "Star a repo ComposioHQ/composio on GitHub"
# Create a chat completion request to decide on the action
response = openai_client.chat.completions.create(
model="gpt-4-turbo",
tools=actions, # Passing actions we fetched earlier.
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": my_task}
]
)
Sử dụng đoạn mã Python này để tạo một tác nhân AI tự động gắn sao cho kho lưu trữ GitHub.
Bạn có thể truy cập Composio qua liên kết sau đây: https://composio.dev/
2. Letta - Xây dựng ứng dụng LLM Stateful
Letta là nền tảng lý tưởng của bạn để xây dựng các ứng dụng thông minh, stateful được hỗ trợ bởi các mô hình ngôn ngữ lớn (LLM). Nó giống như việc cung cấp bộ nhớ cho hệ thống AI để chúng có thể cung cấp kết quả dài hạn, được cá nhân hóa và theo ngữ cảnh.
Thêm vào đó, nó là mã nguồn mở và model-agnostic, nghĩa là bạn có thể tích hợp bất kỳ LLM nào và cải thiện nó bằng các công cụ tùy chỉnh, bộ nhớ dài hạn và các nguồn dữ liệu bên ngoài. Nó giống như việc cung cấp cho AI của bạn một bộ não có khả năng ghi nhớ!
Bạn có thể xây dựng:
- Chatbot được cá nhân hóa yêu cầu bộ nhớ dài hạn
- Tác nhân AI được kết nối với bất kỳ công cụ tùy chỉnh nào
- Tác nhân AI để tự động hóa quy trình làm việc như quản lý email, v.v.
Bắt đầu với Letta. Cài đặt thư viện Letta:
pip install letta
Bạn có thể sử dụng Letta CLI để tạo một tác nhân.
letta run
Nó sẽ bắt đầu tạo một tác nhân AI. Chạy máy chủ letta để truy cập tác nhân AI mới được tạo này.
letta server
Hãy gửi một tin nhắn đến tác nhân này.
from letta import create_client
# connect to the server
client = create_client(base_url="http://localhost:8283")
# send a message to the agent
response = client.send_message(
agent_id="agent-09950586-6313-421c-bf7e-2bba03c30826",
role="user",
message="hey!! how are you?"
)
Với letta server, Môi trường Phát triển Tác nhân (ADE) có thể được tạo để tạo và quản lý các tác nhân.
Bạn có thể truy cập Letta qua liên kết sau đây: https://www.letta.com/
3. Rasa - Xây dựng Trải nghiệm AI Đàm thoại
Rasa là một nền tảng mã nguồn mở giúp việc xây dựng các ứng dụng AI đàm thoại tiên tiến trở nên dễ dàng. Với Rasa, bạn có thể tạo chatbot thông minh và trợ lý ảo thực sự hiểu ngôn ngữ tự nhiên.
Nó cung cấp cho bạn tất cả các công cụ và cơ sở hạ tầng bạn cần để phát triển, đào tạo và triển khai các trợ lý AI thông minh, theo ngữ cảnh, mang lại cảm giác chân thực như con người.
Việc bắt đầu với Rasa rất dễ dàng. Sử dụng kho lưu trữ này để tạo codespace. Thêm API key của bạn.
RASA_PRO_LICENSE='your_rasa_pro_license_key_here'
OPENAI_API_KEY='your_openai_api_key_here'
Tải các biến môi trường này từ tệp của bạn.
source .env
Kích hoạt môi trường Python của bạn.
source .venv/bin/activate
Bạn có thể truy cập vào Rasa qua liên kết này: https://rasa.com/
4. Taipy - Xây dựng ứng dụng web AI
Gặp gỡ Taipy, thư viện Python nguồn mở được thiết kế để đơn giản hóa quy trình phát triển và giữ mọi thứ thân thiện với người dùng. Taipy cung cấp các công cụ để xây dựng các ứng dụng web dựa trên dữ liệu.
Nó cung cấp các công cụ để đơn giản hóa quá trình phát triển quy trình làm việc, bảng điều khiển và các ứng dụng dựa trên dữ liệu khác. Taipy chủ yếu được sử dụng để tạo ra các giải pháp đầu cuối liên quan đến các mô hình học máy và giao diện người dùng tương tác, giúp triển khai các ứng dụng AI dễ dàng hơn.
Sau đây là cách bạn có thể bắt đầu với Taipy.
Cài đặt thư viện Taipy.
pip install taipy
Bây giờ, hãy tạo Giao diện người dùng đồ họa (GUI) bằng Taipy.
Nhập thư viện Taipy cùng với các thư viện cần thiết khác.
from taipy.gui import Gui
import taipy.gui.builder as tgb
from math import cos, exp
Tạo các hàm tiện ích
value = 10
def compute_data(decay:int)->list:
return [cos(i/6) * exp(-i*decay/600) for i in range(100)]
def slider_moved(state):
state.data = compute_data(state.value)
Xây dựng GUI bằng phương pháp Taipy.
with tgb.Page() as page:
tgb.text(value="# Taipy Getting Started", mode="md")
tgb.text(value="Value: {value}")
tgb.slider(value="{value}", on_change=slider_moved)
tgb.chart(data="{data}")
data = compute_data(value)
if __name__ == "__main__":
Gui(page=page).run(title="Dynamic chart")
Cuối cùng, sử dụng lệnh sau để chạy tệp này.
taipy run main.py
Bạn có thể truy cập Taipy qua liên kết sau đây: https://taipy.io/
5. Flowise - Đơn giản hóa việc tạo quy trình làm việc hướng AI
FlowiseAI là nền tảng mã nguồn mở giúp việc tạo và triển khai quy trình làm việc hướng AI trở nên đơn giản hơn rất nhiều. Nó được xây dựng dành cho các nhà khoa học dữ liệu và nhà phát triển, giúp bạn quản lý các mô hình học máy, tự động hóa các quy trình và tích hợp AI liền mạch vào các ứng dụng kinh doanh. Từ thiết kế đến mở rộng quy trình làm việc, FlowiseAI sẽ hỗ trợ bạn.
Nó cho phép người dùng dễ dàng tự động hóa và quản lý quy trình làm việc liên quan đến đào tạo, triển khai và suy luận mô hình.
Bắt đầu với Flowise. Sao chép Kho lưu trữ Flowise.
git clone https://github.com/FlowiseAI/Flowise.git
Điều hướng đến thư mục Flowise.
cd Flowise
Cài đặt các phụ thuộc cần thiết.
pnpm install
Xây dựng mã.
pnpm build
Cuối cùng, hãy chạy ứng dụng.
pnpm start
Bạn có thể truy cập Flowise qua liên kết này nhé: https://flowiseai.com/
6. WandB - Tinh chỉnh mô hình AI của bạn
Weights & Biases (WandB) là công cụ theo dõi và quản lý các thí nghiệm học máy của bạn. Công cụ này giúp bạn theo dõi các mô hình, so sánh các phiên bản và phân tích hiệu suất cực kỳ dễ dàng. Với WandB, bạn có thể tạo báo cáo, chia sẻ kết quả với nhóm của mình và sắp xếp công việc của mình ở một nơi.
Nó hoàn hảo để xây dựng các mô hình AI tốt hơn, nhanh hơn và cộng tác hiệu quả hơn.
Sau đây là cách bạn có thể sử dụng WandB trong các dự án của mình.
Cài đặt thư viện WandB.
!pip install wandb
Đăng nhập vào Wandb.
wandb.login()
Bạn sẽ cần cung cấp khóa API để đăng nhập thành công. Tạo khóa API tại đây: https://wandb.ai/authorize
Khởi tạo đối tượng WandB trong tập lệnh Python của bạn.
run = wandb.init(
# Set the project where this run will be logged
project="my-awesome-project",
# Track hyperparameters and run metadata
config={
"learning_rate": 0.01,
"epochs": 10,
},
)
Sau đây là toàn bộ mã:
# train.py
import wandb
import random # for demo script
wandb.login()
epochs = 10
lr = 0.01
run = wandb.init(
# Set the project where this run will be logged
project="my-awesome-project",
# Track hyperparameters and run metadata
config={
"learning_rate": lr,
"epochs": epochs,
},
)
offset = random.random() / 5
print(f"lr: {lr}")
# simulating a training run
for epoch in range(2, epochs):
acc = 1 - 2**-epoch - random.random() / epoch - offset
loss = 2**-epoch + random.random() / epoch + offset
print(f"epoch={epoch}, accuracy={acc}, loss={loss}")
wandb.log({"accuracy": acc, "loss": loss})
# run.log_code()
Bây giờ, bạn có thể điều hướng đến bảng điều khiển WandB và xem số liệu.
Bạn có thể truy cập vào Wandb qua liên kết sau: https://wandb.ai/site/
7. Ludwig - Xây dựng mô hình AI tùy chỉnh
Ludwig, công cụ học sâu mã nguồn mở được xây dựng bằng Python để giúp mọi người có thể tiếp cận học máy—kể cả khi bạn không phải là chuyên gia lập trình. Với giao diện đơn giản, bạn có thể xây dựng, đào tạo và triển khai các mô hình một cách dễ dàng, do đó bạn có thể tập trung vào kết quả mà không phải lo lắng về các chi tiết phức tạp bên dưới.
Bắt đầu với Ludwig.
Cài đặt thư viện Ludwig.
pip install ludwig
Nhập các thư viện cần thiết.
config = {
"input_features": [
{
"name": "sepal_length_cm",
"type": "number"
},
{
"name": "sepal_width_cm",
"type": "number"
},
{
"name": "petal_length_cm",
"type": "number"
},
{
"name": "petal_width_cm",
"type": "number"
}
],
"output_features": [
{
"name": "class",
"type": "category"
}
]
}
model = LudwigModel(config)
data = pd.read_csv("data.csv")
train_stats, _, model_dir = model.train(data)
Tải một mô hình.
model = LudwigModel.load(model_dir)
Ghi lại các dự đoán.
predictions = model.predict(data)
Và mô hình LLM của bạn đã được tạo thành công.
Bạn có thể truy cập Ludwig qua liên kết sau đây: https://ludwig.ai/latest/
8. Feast - Cửa hàng tính năng cho ML sản xuất
Feast, kho tính năng nguồn mở được xây dựng dành riêng cho các ứng dụng học máy. Nó hoạt động như một nền tảng để lưu trữ, quản lý và phục vụ các tính năng (thuộc tính dữ liệu) cho các mô hình ML của bạn. Với Feast, bạn có thể truy cập dữ liệu hiệu quả, cho dù bạn đang đào tạo hay phục vụ các mô hình.
Nó có thể được tích hợp liền mạch vào quy trình làm việc ML, cho phép các nhà khoa học dữ liệu và kỹ sư truy cập các tính năng trong cả môi trường đào tạo và sản xuất.
Bắt đầu với Feast.
pip install feast
Tạo kho lưu trữ Feast cho dự án của bạn.
feast init my_project
cd my_project/feature_repo
Tạo dữ liệu đào tạo để dự án của bạn được đào tạo.
from datetime import datetime
import pandas as pd
from feast import FeatureStore
# Note: see https://docs.feast.dev/getting-started/concepts/feature-retrieval for
# more details on how to retrieve for all entities in the offline store instead
entity_df = pd.DataFrame.from_dict(
{
# entity's join key -> entity values
"driver_id": [1001, 1002, 1003],
# "event_timestamp" (reserved key) -> timestamps
"event_timestamp": [
datetime(2021, 4, 12, 10, 59, 42),
datetime(2021, 4, 12, 8, 12, 10),
datetime(2021, 4, 12, 16, 40, 26),
],
# (optional) label name -> label values. Feast does not process these
"label_driver_reported_satisfaction": [1, 5, 3],
# values we're using for an on-demand transformation
"val_to_add": [1, 2, 3],
"val_to_add_2": [10, 20, 30],
}
)
store = FeatureStore(repo_path=".")
training_df = store.get_historical_features(
entity_df=entity_df,
features=[
"driver_hourly_stats:conv_rate",
"driver_hourly_stats:acc_rate",
"driver_hourly_stats:avg_daily_trips",
"transformed_conv_rate:conv_rate_plus_val1",
"transformed_conv_rate:conv_rate_plus_val2",
],
).to_df()
print("----- Feature schema -----\n")
print(training_df.info())
print()
print("----- Example features -----\n")
print(training_df.head())
Nhập các tính năng hàng loạt vào cửa hàng trực tuyến của bạn.
CURRENT_TIME=$(date -u +"%Y-%m-%dT%H:%M:%S")
# For mac
LAST_YEAR=$(date -u -v -1y +"%Y-%m-%dT%H:%M:%S")
# For Linux
# LAST_YEAR=$(date -u -d "last year" +"%Y-%m-%dT%H:%M:%S")
feast materialize-incremental $LAST_YEAR $CURRENT_TIME
Lấy các vectơ đặc trưng để suy luận.
from pprint import pprint
from feast import FeatureStore
store = FeatureStore(repo_path=".")
feature_vector = store.get_online_features(
features=[
"driver_hourly_stats:conv_rate",
"driver_hourly_stats:acc_rate",
"driver_hourly_stats:avg_daily_trips",
],
entity_rows=[
# {join_key: entity_value}
{"driver_id": 1004},
{"driver_id": 1005},
],
).to_dict()
pprint(feature_vector)
Thay vào đó, hãy sử dụng dịch vụ tính năng để lấy các tính năng trực tuyến.
from feast import FeatureService
driver_stats_fs = FeatureService(
name="driver_activity_v1", features=[driver_stats_fv]
)
Dự án của bạn đã sẵn sàng.
Bạn có thể truy cập Feast qua liên kết sau: https://feast.dev/
9. ONNX Runtime - Công cụ AI cấp sản xuất để tăng tốc quá trình đào tạo
Hãy làm quen với ONNX Runtime, công cụ mã nguồn mở, hiệu suất cao được xây dựng để tăng cường các mô hình học máy theo định dạng Open Neural Network Exchange (ONNX) . Được phát triển bởi Microsoft, đây là công cụ bạn cần để triển khai các mô hình ML với hiệu suất và tốc độ cao trên nhiều nền tảng khác nhau.
ONNX Runtime chạy trên nhiều nền tảng, bao gồm Windows, Linux và macOS, cũng như các thiết bị biên và nền tảng di động.
Để sử dụng ONNX, bạn chỉ cần cài đặt thư viện của nó.
pip install onnxruntime
ONNX được hỗ trợ bởi PyTroch, TensorFlow và SciKit Learn.
Hãy sử dụng PyTorch cho mục đích demo.
Xuất mô hình bằng cách sử dụng torch.onnx.report.
torch.onnx.export(model, # model being run
torch.randn(1, 28, 28).to(device), # model input (or a tuple for multiple inputs)
"fashion_mnist_model.onnx", # where to save the model (can be a file or file-like object)
input_names = ['input'], # the model's input names
output_names = ['output']) # the model's output names
Tải mô hình onnx với onnx.load.
import onnx
onnx_model = onnx.load("fashion_mnist_model.onnx")
onnx.checker.check_model(onnx_model)
Tạo phiên suy luận bằng cách sử dụng ort.InferenceSession.
import onnxruntime as ort
import numpy as np
x, y = test_data[0][0], test_data[0][1]
ort_sess = ort.InferenceSession('fashion_mnist_model.onnx')
outputs = ort_sess.run(None, {'input': x.numpy()})
# Print Result
predicted, actual = classes[outputs[0][0].argmax(0)], classes[y]
print(f'Predicted: "{predicted}", Actual: "{actual}"')
Tương tự như vậy, bạn có thể sử dụng TensorFlow hoặc Scikit Learn.
Bạn có thể truy cập ONNX Runtime qua liên kết này nhé: https://onnxruntime.ai/
Cảm ơn các bạn đã theo dõi bài viết!
All rights reserved
