Dalam persekitaran perniagaan yang pantas hari ini, organisasi dibanjiri dengan data yang mendorong keputusan, mengoptimumkan operasi, dan mengekalkan daya saing. Walau bagaimanapun, mengekstrak pandangan yang boleh diambil tindakan dari data ini kekal sebagai halangan penting. Sistem generasi pengambilan semula (RAG), apabila diintegrasikan dengan AIS AIS, menangani cabaran ini dengan tidak hanya mendapatkan maklumat yang relevan tetapi juga memproses dan menyampaikan pandangan konteks yang menyedari konteks dalam masa nyata. Gabungan ini membolehkan perniagaan membuat ejen pintar yang secara autonomi menanyakan dataset, menyesuaikan, dan mengekstrak pandangan mengenai ciri produk, integrasi, dan operasi.
Dengan menggabungkan RAG dengan agentik AI, perniagaan dapat meningkatkan membuat keputusan dan menukar data yang bertaburan ke dalam kecerdasan yang berharga. Blog ini meneroka proses membina saluran paip RAG dengan AIS AI, menawarkan pandangan teknikal dan contoh kod untuk memperkasakan pengambilan keputusan pintar dalam organisasi.
inilah kod untuk melakukan pengekstrakan pautan:
kami mengekalkan barisan untuk mengesan URL untuk melawat bersama dengan kedalaman yang sama, memastikan traversal yang cekap. Set yang dikunjungi digunakan untuk mengelakkan menyemak semula URL yang sama beberapa kali. Untuk setiap URL, kami menggunakan BeautifulSoup untuk menghuraikan HTML dan mengekstrak semua pautan (tag dengan atribut HREF). Proses ini menggunakan BFS traversal, mengambil rekursif setiap kandungan URL, mengekstrak pautan, dan meneroka lagi sehingga mencapai had kedalaman. Pendekatan ini memastikan kami meneroka web dengan cekap tanpa redundansi.
Kod ini mengeluarkan senarai pautan yang diekstrak dari laman web, sehingga kedalaman yang ditentukan.
output menunjukkan bahawa sistem yang dijumpai dan dikumpulkan 1500 pautan dari laman web permulaan dan halaman yang dikaitkan sehingga kedalaman 3. Anda akan menggantikan https://www.example.com dengan URL sasaran sebenar anda. Berikut adalah tangkapan skrin output kod asal. Maklumat sensitif telah bertopeng untuk mengekalkan integriti.
Sebaik sahaja kami telah mengekstrak pautan yang berkaitan dengan menggunakan BFS, langkah seterusnya adalah untuk mengikis kandungan dari halaman ini. Kami akan mencari maklumat penting seperti ciri produk, integrasi, dan data lain yang berkaitan yang akan membantu kami membina dataset berstruktur untuk sistem RAG.
Dalam langkah ini, kami gelung melalui senarai pautan yang diekstrak dan mengikis kandungan utama, seperti tajuk halaman dan kandungan utamanya. Anda boleh menyesuaikan kod ini untuk mengikis titik data tambahan seperti yang diperlukan (mis., Ciri produk, harga, atau maklumat FAQ).
import requests
from bs4 import BeautifulSoup
from collections import deque
# Function to extract links using BFS
def bfs_link_extraction(start_url, max_depth=3):
visited = set() # To track visited links
queue = deque([(start_url, 0)]) # Queue to store URLs and current depth
all_links = []
while queue:
url, depth = queue.popleft()
if depth > max_depth:
continue
# Fetch the content of the URL
try:
response = requests.get(url)
soup = BeautifulSoup(response.content, 'html.parser')
# Extract all links in the page
links = soup.find_all('a', href=True)
for link in links:
full_url = link['href']
if full_url.startswith('http') and full_url not in visited:
visited.add(full_url)
queue.append((full_url, depth + 1))
all_links.append(full_url)
except requests.exceptions.RequestException as e:
print(f"Error fetching {url}: {e}")
return all_links
# Start the BFS from the homepage
start_url = 'https://www.example.com' # Replace with the actual homepage URL
all_extracted_links = bfs_link_extraction(start_url)
print(f"Extracted {len(all_extracted_links)} links.")Untuk setiap URL dalam senarai, kami menghantar permintaan HTTP untuk mengambil kandungan halaman dan menghuraikannya menggunakan BeautifulSoup untuk mengekstrak tajuk dan kandungan utama. Kami menyimpan data yang diekstrak dalam senarai kamus, masing -masing mengandungi URL, tajuk, dan kandungan. Akhirnya, kami menyimpan data yang dikikis ke dalam fail JSON, memastikan ia tersedia untuk pemprosesan kemudian dalam saluran paip RAG. Proses ini memastikan pengumpulan dan penyimpanan data yang relevan untuk kegunaan selanjutnya.
Output kod ini akan menjadi fail JSON yang disimpan (scraped_data.json) yang mengandungi data yang dikikis dari pautan. Contoh struktur data boleh kelihatan seperti ini:
Extracted 1500 links.
Fail JSON ini mengandungi URL, tajuk, dan kandungan untuk setiap halaman yang kami dikikis. Data berstruktur ini kini boleh digunakan untuk pemprosesan selanjutnya, seperti penyembuhan generasi dan soal jawab dalam sistem RAG. Berikut adalah tangkapan skrin output kod asal. Maklumat sensitif telah bertopeng untuk mengekalkan integriti.
Dalam seksyen ini, kami memberi tumpuan kepada bagaimana Agentic AI mengekstrak maklumat produk yang relevan dari data yang dikikis, memastikan ia bersedia untuk penggunaan pihak berkepentingan. Kami akan memecahkan langkah -langkah utama yang terlibat, dari memuatkan data untuk memprosesnya dan akhirnya menyimpan hasil dalam format berstruktur.
Langkah 1: Memuatkan data yang dikikis
coretan kod:
import requests
from bs4 import BeautifulSoup
from collections import deque
# Function to extract links using BFS
def bfs_link_extraction(start_url, max_depth=3):
visited = set() # To track visited links
queue = deque([(start_url, 0)]) # Queue to store URLs and current depth
all_links = []
while queue:
url, depth = queue.popleft()
if depth > max_depth:
continue
# Fetch the content of the URL
try:
response = requests.get(url)
soup = BeautifulSoup(response.content, 'html.parser')
# Extract all links in the page
links = soup.find_all('a', href=True)
for link in links:
full_url = link['href']
if full_url.startswith('http') and full_url not in visited:
visited.add(full_url)
queue.append((full_url, depth + 1))
all_links.append(full_url)
except requests.exceptions.RequestException as e:
print(f"Error fetching {url}: {e}")
return all_links
# Start the BFS from the homepage
start_url = 'https://www.example.com' # Replace with the actual homepage URL
all_extracted_links = bfs_link_extraction(start_url)
print(f"Extracted {len(all_extracted_links)} links.")Di sini, kami memuatkan keseluruhan dataset ke dalam memori menggunakan perpustakaan JSON terbina dalam Python. Setiap entri dalam dataset mengandungi URL sumber dan medan text_content, yang memegang teks dikikis mentah. Kandungan ini adalah apa yang akan kita proses dalam langkah seterusnya.
Seterusnya, kami melangkah melalui dataset untuk mengekstrak text_content yang berkaitan untuk setiap entri. Ini memastikan bahawa kami hanya bekerja dengan entri yang sah yang mengandungi kandungan yang diperlukan. Penyertaan yang tidak sah atau tidak lengkap dilangkau untuk mengekalkan integriti proses.
coretan kod:
Extracted 1500 links.
Pada ketika ini, pembolehubah input_text mengandungi kandungan teks mentah yang akan kami hantar ke model AI untuk pemprosesan selanjutnya. Adalah penting bahawa kami memastikan kehadiran kunci yang diperlukan sebelum memproses setiap entri.
Selepas mengekstrak kandungan mentah, kami menghantarnya ke model AI AIS untuk pengekstrakan berstruktur. Kami berinteraksi dengan API Groq untuk meminta pandangan berstruktur berdasarkan arahan yang telah ditetapkan. Model AI memproses kandungan dan mengembalikan maklumat teratur yang meliputi aspek utama seperti keupayaan produk, integrasi, dan langkah penyelesaian masalah.
coretan kod:
import json
# Function to scrape and extract data from the URLs
def scrape_data_from_links(links):
scraped_data = []
for link in links:
try:
response = requests.get(link)
soup = BeautifulSoup(response.content, 'html.parser')
# Example: Extract 'title' and 'content' (modify according to your needs)
title = soup.find('title').get_text()
content = soup.find('div', class_='content').get_text() # Adjust selector
# Store the extracted data
scraped_data.append({
'url': link,
'title': title,
'content': content
})
except requests.exceptions.RequestException as e:
print(f"Error scraping {link}: {e}")
return scraped_data
# Scrape data from the extracted links
scraped_contents = scrape_data_from_links(all_extracted_links)
# Save scraped data to a JSON file
with open('/content/scraped_data.json', 'w') as outfile:
json.dump(scraped_contents, outfile, indent=4)
print("Data scraping complete.")di sini, kod ini memulakan panggilan API ke Groq, menghantar input_text dan arahan sebagai sebahagian daripada muatan mesej. Mesej sistem mengarahkan model AI pada tugas yang tepat untuk dilakukan, sementara mesej pengguna menyediakan kandungan yang akan diproses. Kami menggunakan parameter suhu, max_tokens, dan top_p untuk mengawal rawak dan panjang output yang dihasilkan.
Konfigurasi panggilan API:
coretan kod:
import requests
from bs4 import BeautifulSoup
from collections import deque
# Function to extract links using BFS
def bfs_link_extraction(start_url, max_depth=3):
visited = set() # To track visited links
queue = deque([(start_url, 0)]) # Queue to store URLs and current depth
all_links = []
while queue:
url, depth = queue.popleft()
if depth > max_depth:
continue
# Fetch the content of the URL
try:
response = requests.get(url)
soup = BeautifulSoup(response.content, 'html.parser')
# Extract all links in the page
links = soup.find_all('a', href=True)
for link in links:
full_url = link['href']
if full_url.startswith('http') and full_url not in visited:
visited.add(full_url)
queue.append((full_url, depth + 1))
all_links.append(full_url)
except requests.exceptions.RequestException as e:
print(f"Error fetching {url}: {e}")
return all_links
# Start the BFS from the homepage
start_url = 'https://www.example.com' # Replace with the actual homepage URL
all_extracted_links = bfs_link_extraction(start_url)
print(f"Extracted {len(all_extracted_links)} links.")
Coretan Kod ini menggabungkan kandungan dari setiap bahagian ke pm_points pembolehubah, menghasilkan satu set wawasan yang penuh dan berstruktur. Ia mengekstrak pandangan ini dalam format yang pihak berkepentingan dengan mudah boleh menggunakan atau menggunakan untuk analisis selanjutnya. Berikut adalah tangkapan skrin output kod asal, dengan maklumat sensitif bertopeng untuk mengekalkan integriti.
Semasa memproses, selalu ada kemungkinan menghadapi kesilapan, seperti kandungan atau isu rangkaian yang tidak lengkap. Dengan menggunakan mekanisme pengendalian ralat, kami memastikan bahawa proses terus lancar untuk semua entri yang sah.
coretan kod:
Extracted 1500 links.
Blok Cuba-Except ini menangkap dan log sebarang kesilapan, memastikan sistem terus memproses entri lain. Sekiranya entri tertentu menyebabkan masalah, sistem menandakannya untuk semakan tanpa menghentikan proses keseluruhan.
Selepas AI memproses kandungan dan mengembalikan pandangan berstruktur, langkah terakhir menyimpan data ini untuk kegunaan kemudian. Kami menulis hasil berstruktur kembali ke fail JSON, memastikan bahawa setiap entri mempunyai maklumat yang diproses sendiri yang disimpan untuk analisis selanjutnya.
coretan kod:
import json
# Function to scrape and extract data from the URLs
def scrape_data_from_links(links):
scraped_data = []
for link in links:
try:
response = requests.get(link)
soup = BeautifulSoup(response.content, 'html.parser')
# Example: Extract 'title' and 'content' (modify according to your needs)
title = soup.find('title').get_text()
content = soup.find('div', class_='content').get_text() # Adjust selector
# Store the extracted data
scraped_data.append({
'url': link,
'title': title,
'content': content
})
except requests.exceptions.RequestException as e:
print(f"Error scraping {link}: {e}")
return scraped_data
# Scrape data from the extracted links
scraped_contents = scrape_data_from_links(all_extracted_links)
# Save scraped data to a JSON file
with open('/content/scraped_data.json', 'w') as outfile:
json.dump(scraped_contents, outfile, indent=4)
print("Data scraping complete.")Kod ini menyimpan data yang diproses dengan cekap dan membolehkan akses mudah kemudian. Ia menjimatkan setiap entri dengan titik berstruktur masing -masing, membuat pengambilan dan analisis maklumat yang diekstrak dengan mudah.
Selepas menjalankan kod di atas, fail JSON yang diproses akan mengandungi titik yang diekstrak untuk setiap entri. Bidang PM_Points akan memegang maklumat berstruktur yang berkaitan dengan keupayaan produk, integrasi, langkah penyelesaian masalah, dan banyak lagi, bersedia untuk analisis atau integrasi selanjutnya ke dalam aliran kerja anda.
[
{
"url": "https://www.example.com/page1",
"title": "Page 1 Title",
"content": "This is the content of the first page. It contains
information about integrations and features."
},
{
"url": "https://www.example.com/page2",
"title": "Page 2 Title",
"content": "Here we describe the functionalities of the product.
It includes various use cases and capabilities."
}
]di bawah adalah tangkapan skrin output kod asal. Maklumat sensitif telah bertopeng untuk mengekalkan integriti.
Membangun pada bahagian ini, kami akan melaksanakan saluran paip generasi pengambilan semula (RAG), yang menggabungkan penjanaan model pengambilan dan bahasa untuk menjawab soalan berdasarkan maklumat yang diekstrak.
Dengan mengintegrasikan data berstruktur yang kami telah dikikis dan diproses sebelum ini, saluran paip RAG ini bukan sahaja akan mengambil potongan dokumen yang paling relevan tetapi juga menghasilkan respons yang tepat dan berwawasan berdasarkan konteks itu.
Untuk memulakan, mari kita pasang semua kebergantungan yang diperlukan untuk saluran paip RAG:
import requests
from bs4 import BeautifulSoup
from collections import deque
# Function to extract links using BFS
def bfs_link_extraction(start_url, max_depth=3):
visited = set() # To track visited links
queue = deque([(start_url, 0)]) # Queue to store URLs and current depth
all_links = []
while queue:
url, depth = queue.popleft()
if depth > max_depth:
continue
# Fetch the content of the URL
try:
response = requests.get(url)
soup = BeautifulSoup(response.content, 'html.parser')
# Extract all links in the page
links = soup.find_all('a', href=True)
for link in links:
full_url = link['href']
if full_url.startswith('http') and full_url not in visited:
visited.add(full_url)
queue.append((full_url, depth + 1))
all_links.append(full_url)
except requests.exceptions.RequestException as e:
print(f"Error fetching {url}: {e}")
return all_links
# Start the BFS from the homepage
start_url = 'https://www.example.com' # Replace with the actual homepage URL
all_extracted_links = bfs_link_extraction(start_url)
print(f"Extracted {len(all_extracted_links)} links.")Pakej -pakej ini penting untuk mengintegrasikan pemprosesan dokumen, vektorisasi, dan model terbuka dalam Langchain. JQ adalah pemproses JSON yang ringan, sementara Langchain berfungsi sebagai kerangka teras untuk membina saluran paip model bahasa. Langchain-Openai memudahkan integrasi model terbuka seperti GPT, dan Langchain-Chroma menawarkan kedai vektor berasaskan Chroma untuk menguruskan embeddings dokumen.
Selain itu, kami menggunakan transformer kalimat untuk menjana embedding teks dengan model pengubah pra-terlatih, membolehkan pengendalian dan pengambilan dokumen yang cekap.
Sekarang, kami akan memuatkan data berstruktur yang telah diekstrak dan diproses di bahagian sebelumnya menggunakan jsonLoader. Data ini, misalnya, boleh dikikis dari laman web sebagai JSON berstruktur, dengan pasangan nilai utama yang berkaitan dengan topik atau soalan tertentu.
Extracted 1500 links.
Dalam langkah ini, data yang sebelum ini diekstrak (mungkin mengandungi keupayaan produk, integrasi, dan ciri) dimuatkan untuk pemprosesan selanjutnya.
Sekarang kita mempunyai data mentah, kita menggunakan recursiveCharactertextsplitter untuk memecahkan dokumen ke dalam ketulan yang lebih kecil. Ini memastikan bahawa tiada bahagian tunggal melebihi had token model bahasa.
import json
# Function to scrape and extract data from the URLs
def scrape_data_from_links(links):
scraped_data = []
for link in links:
try:
response = requests.get(link)
soup = BeautifulSoup(response.content, 'html.parser')
# Example: Extract 'title' and 'content' (modify according to your needs)
title = soup.find('title').get_text()
content = soup.find('div', class_='content').get_text() # Adjust selector
# Store the extracted data
scraped_data.append({
'url': link,
'title': title,
'content': content
})
except requests.exceptions.RequestException as e:
print(f"Error scraping {link}: {e}")
return scraped_data
# Scrape data from the extracted links
scraped_contents = scrape_data_from_links(all_extracted_links)
# Save scraped data to a JSON file
with open('/content/scraped_data.json', 'w') as outfile:
json.dump(scraped_contents, outfile, indent=4)
print("Data scraping complete.")RecursiveCharactertextsplitter membahagikan dokumen ke dalam segmen yang lebih kecil, memastikan pertindihan yang dipelihara dipelihara untuk pemahaman kontekstual yang lebih baik. Parameter chunk_size menentukan saiz setiap bahagian, manakala chunk_overlap memastikan maklumat penting dikekalkan di bahagian -bahagian bersebelahan. Di samping itu, add_start_index membantu mengekalkan pesanan dokumen dengan memasukkan indeks, yang membolehkan pengesanan mudah di mana setiap bahagian berasal dari dokumen asal.
Sekarang, kita menukar setiap bahagian teks ke dalam embeddings menggunakan sentenceTransformer. Lembaran ini mewakili makna teks dalam ruang vektor dimensi tinggi, yang berguna untuk mencari dan mengambil dokumen yang relevan kemudian.
[
{
"url": "https://www.example.com/page1",
"title": "Page 1 Title",
"content": "This is the content of the first page. It contains
information about integrations and features."
},
{
"url": "https://www.example.com/page2",
"title": "Page 2 Title",
"content": "Here we describe the functionalities of the product.
It includes various use cases and capabilities."
}
]SentenceTransformer digunakan untuk menghasilkan embeddings untuk ketulan teks, mewujudkan perwakilan vektor padat yang menangkap maklumat semantik. Fungsi embed_documents memproses pelbagai dokumen dan mengembalikan embeddings mereka, sementara Embed_Query menghasilkan embeddings untuk pertanyaan pengguna. Chroma, kedai vektor, menguruskan embeddings ini dan membolehkan pengambilan semula yang cekap berdasarkan persamaan, yang membolehkan dokumen cepat dan tepat atau pemadanan pertanyaan.
Sekarang kita mengkonfigurasi retriever. Komponen ini mencari potongan teks yang paling relevan berdasarkan pertanyaan pengguna. Ia mengambil bahagian-bahagian dokumen yang paling serupa dengan pertanyaan.
import requests
from bs4 import BeautifulSoup
from collections import deque
# Function to extract links using BFS
def bfs_link_extraction(start_url, max_depth=3):
visited = set() # To track visited links
queue = deque([(start_url, 0)]) # Queue to store URLs and current depth
all_links = []
while queue:
url, depth = queue.popleft()
if depth > max_depth:
continue
# Fetch the content of the URL
try:
response = requests.get(url)
soup = BeautifulSoup(response.content, 'html.parser')
# Extract all links in the page
links = soup.find_all('a', href=True)
for link in links:
full_url = link['href']
if full_url.startswith('http') and full_url not in visited:
visited.add(full_url)
queue.append((full_url, depth + 1))
all_links.append(full_url)
except requests.exceptions.RequestException as e:
print(f"Error fetching {url}: {e}")
return all_links
# Start the BFS from the homepage
start_url = 'https://www.example.com' # Replace with the actual homepage URL
all_extracted_links = bfs_link_extraction(start_url)
print(f"Extracted {len(all_extracted_links)} links.")Seterusnya, kami membuat templat segera yang akan memformat input untuk model bahasa. Templat ini merangkumi kedua -dua konteks (potongan yang diambil) dan pertanyaan pengguna, membimbing model untuk menghasilkan jawapan berdasarkan hanya pada konteks yang disediakan.
Extracted 1500 links.
Dalam langkah ini, kami memulakan model OpenAI GPT. Model ini akan menghasilkan jawapan berdasarkan konteks berstruktur yang disediakan oleh retriever.
import json
# Function to scrape and extract data from the URLs
def scrape_data_from_links(links):
scraped_data = []
for link in links:
try:
response = requests.get(link)
soup = BeautifulSoup(response.content, 'html.parser')
# Example: Extract 'title' and 'content' (modify according to your needs)
title = soup.find('title').get_text()
content = soup.find('div', class_='content').get_text() # Adjust selector
# Store the extracted data
scraped_data.append({
'url': link,
'title': title,
'content': content
})
except requests.exceptions.RequestException as e:
print(f"Error scraping {link}: {e}")
return scraped_data
# Scrape data from the extracted links
scraped_contents = scrape_data_from_links(all_extracted_links)
# Save scraped data to a JSON file
with open('/content/scraped_data.json', 'w') as outfile:
json.dump(scraped_contents, outfile, indent=4)
print("Data scraping complete.")di sini, kami mengintegrasikan semua komponen (retriever, prompt, llm) ke dalam saluran paip kain kohesif. Paip ini akan mengambil pertanyaan, mengambil konteks yang relevan, melewati model, dan menghasilkan respons.
[
{
"url": "https://www.example.com/page1",
"title": "Page 1 Title",
"content": "This is the content of the first page. It contains
information about integrations and features."
},
{
"url": "https://www.example.com/page2",
"title": "Page 2 Title",
"content": "Here we describe the functionalities of the product.
It includes various use cases and capabilities."
}
]Akhirnya, kami menguji saluran paip dengan pelbagai pertanyaan pengguna. Untuk setiap pertanyaan, sistem mengambil potongan dokumen yang relevan, melewati mereka melalui model bahasa, dan menghasilkan respons.
import json
# Load the scraped JSON file containing the web data
with open('/content/scraped_contents_zluri_all_links.json', 'r') as file:
data = json.load(file)di bawah adalah tangkapan skrin output RAG dari kod asal. Maklumat sensitif telah bertopeng untuk mengekalkan integriti.
Dengan menggabungkan pengikis web, pengekstrakan data, dan teknik generasi pengambilan semula (RAG), kami telah mencipta rangka kerja yang kuat dan berskala untuk kecerdasan syarikat. Langkah pertama mengekstrak pautan dan mengikis data memastikan kami mengumpulkan maklumat yang relevan dan terkini dari web. Bahagian kedua memberi tumpuan kepada menunjuk butiran berkaitan produk tertentu, menjadikannya lebih mudah untuk mengkategorikan dan memproses data dengan cekap.
Akhirnya, memanfaatkan RAG membolehkan kami memberi respons secara dinamik kepada pertanyaan yang kompleks dengan mengambil dan mensintesis maklumat kontekstual dari dataset yang luas. Bersama -sama, komponen -komponen ini membentuk persediaan yang komprehensif yang boleh digunakan untuk membina platform agentik yang mampu mengumpulkan, memproses, dan menyampaikan pandangan yang dapat ditindaklanjuti oleh syarikat. Rangka kerja ini boleh menjadi asas untuk membangunkan sistem kecerdasan maju, membolehkan organisasi mengautomasikan analisis kompetitif, memantau trend pasaran, dan terus dimaklumkan mengenai industri mereka.
penyebaran dan skalaIni dapat dicapai dengan memanfaatkan kedai vektor yang diedarkan dan mengoptimumkan proses pengambilan semula, memastikan bahawa saluran paip tetap responsif dan cepat walaupun di bawah penggunaan berat. Dengan teknik infrastruktur dan pengoptimuman yang betul di tempat, platform Agentic dapat berkembang untuk menyokong operasi berskala besar, membolehkan pandangan masa nyata dan mengekalkan kelebihan daya saing dalam kecerdasan syarikat.
Kesimpulan
Penyelesaian berskala ini tumbuh dengan keperluan anda, mengendalikan pertanyaan kompleks dan dataset yang lebih besar sambil mengekalkan ketepatan. Dengan infrastruktur yang betul, platform yang didorong oleh AI ini menjadi asas bagi operasi yang lebih bijak, membolehkan organisasi memanfaatkan data mereka, kekal berdaya saing, dan memacu inovasi melalui pengambilan keputusan pintar dalam organisasi.
Bonus: Semua kod yang dibincangkan di sini disediakan dalam pautan berikut. Sebanyak 4 buku nota boleh didapati, dengan nama-nama jelas untuk setiap buku nota. Jangan ragu untuk meneroka, membangun dan merevolusikan perusahaan!
Media yang ditunjukkan dalam artikel ini tidak dimiliki oleh Analytics Vidhya dan digunakan pada budi bicara penulis.
Atas ialah kandungan terperinci Membina sistem kain rag untuk membuat keputusan pintar dalam organisasi. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!
Bolehkah percikan api Douyin dinyalakan semula jika ia telah dimatikan selama lebih daripada tiga hari?
Sepuluh pertukaran mata wang digital teratas
css3transition
Apakah maksud wifi dinyahaktifkan?
Tiga kaedah pencetus pencetus sql
Penggunaan ModifyMenu
Bagaimana untuk mendapatkan Bitcoin
Apa yang perlu dilakukan jika memuatkan dll gagal
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
