Cơ sở tri thức là một phần của khoa học máy tính và trí tuệ nhân tạo, nghiên cứu về việc xây dựng và sử dụng các hệ thống thông minh, tự động học để tự động hóa các tác vụ thông tin, tiế
ĐỒ THỊ TRI THỨC (KNOWLEDGE GRAPH)
CƠ SỞ DỮ LIỆU TRI THỨC YAGO
YAGO là một cơ sở dữ liệu tri thức đại diện cho nhiều lĩnh vực tri thức, được sử dụng rộng rãi trong các ứng dụng như truy vấn thông minh, suy luận, phân giải giải thích và xử lý ngôn ngữ tự nhiên Phát triển của YAGO bắt đầu từ năm 2006 và do các nhà khoa
Too long to read on your phone? Save to read later on your computer
Save to a Studylist học của Đại học Max-Planck ở Đức xây dựng YAGO sử dụng một số nguyên tắc để biểu diễn thông tin tri thức về thế giới thực là các đối tượng tham chiếu đơn giản và rõ ràng(như tên của một quốc gia hoặc một diễn viên) và sử dụng nhiều nguồn dữ liệu khác nhau(như Wikipedia, WordNet) để giúp xác định quan hệ giữa các thực thể khác nhau.YAGO được tổ chức dưới dạng một danh sách các đối tượng khác nhau (như con người, đất nước, sự kiện, văn hóa) và các quan hệ giữa chúng (như là chủ đề sáng tác,quốc tịch, thành phố sinh sống) Các mối quan hệ này được biểu diễn bằng cách sử dụng các bộ ba (triples) có định dạng (subject, predicate, object) YAGO đã được sử dụng rộng rãi trong các lĩnh vực như trí tuệ nhân tạo, xử lý ngôn ngữ tự nhiên, web sematic, hệ thống hỏi đáp và nhiều ứng dụng khác Các tính năng của YAGO - chẳng hạn như phong phú về thông tin, độ chính xác cao cùng về định dạng dữ liệu được tổ chức rõ ràng - đã giúpYAGO trở thành một trong những nguồn tri thức phổ biến nhất được sử dụng trong lọc thông tin và hệ thống hỏi đáp.
BIỂU DIỄN TRI THỨC
Đồ thị tri thức trong YAGO được biểu diễn bằng các bộ ba (triples) gồm ba thành phần chính: đối tượng nguồn (subject), quan hệ (predicate) và đối tượng đích (object) YAGO biểu diễn đồ thị tri thức thông qua các bộ ba như trên, trong đó thực thể và lớp được đại diện bằng các đối tượng trong bộ ba Những đối tượng này sẽ được định danh đầy đủ để loại bỏ mọi sự không rõ ràng trong việc xác định thực thể, giúp cho đồ thị tri thức trở nên dễ hiểu và luôn chính xác.
YAGO xây dựng lên đồ thị tri thức với quan hệ được định nghĩa bằng lĩnh vực khác nhau như kiến trúc, giải trí, địa lý, lịch sử, kinh doanh, thông qua việc tổng hợp thông tin từ các nguồn dữ liệu như Wikipedia, WordNet và các nguồn dữ liệu khác.
Cấu trúc đồ thị tri thức trong YAGO cho phép các ứng dụng xử lý tri thức, ví dụ như tìm kiếm tri thức, suy luận, trích xuất thông tin, phát hiện thông tin mới và nhiều ứng dụng khác.
Sau đây là một ví dụ về biểu diễn đồ thị tri thức chứa 50 triple về lĩnh vực dạy học của giáo viên Võ Thị Thu Liểu của trường THPT TP Cao Lãnh Sau đó đưa vào máy tính và xử lý tìm đường đi: import networkx nxas import matplotlib.pyplot pltas
KG.add_edge('Sở GDĐT Đồng Tháp','Bộ GDĐT', label='trực thuộc')
KG.add_edge('Sở GDĐT Đồng Tháp','Trường Chuyên NQD', label= 'có trường chuyên là') KG.add_edge('Trường THPT TP Cao Lãnh' 'Sở GDĐT Đồng Tháp', , label='trực thuộc') KG.add_edge('Trường THPT TP Cao Lãnh' '8 tổ CM', , label='có')
KG.add_edge('Trường THPT TP Cao Lãnh' 'TP Cao Lãnh Tỉnh Đồng Tháp', , label='có địa chỉ ở')
KG.add_edge('Trường THPT TP Cao Lãnh' 'Môn Tin học', , label='có 4 giáo viên')KG.add_edge('Trường THPT TP Cao Lãnh' 'Lê Văn Lộc', , label='có Hiệu trưởng là')
KG.add_edge('Trường THPT TP Cao Lãnh' 'Phòng Giáo dục và Đào tạo thành phố Cao L, ãnh', label='liên kết')
KG.add_edge('Trường THPT TP Cao Lãnh' 'Hội đồng tư vấn giáo dục trường THPT TP C, ao Lãnh', label='hỗ trợ')
KG.add_edge('Trường THPT TP Cao Lãnh' 'Công ty XKLĐ Đồng Tháp', , label='hợp tác') KG.add_edge('Trường THPT TP Cao Lãnh' 'Hiệp hội giáo dục Đồng Tháp', , label='thành viên')
KG.add_edge('Trường THPT TP Cao Lãnh' 'Công ty du lịch Tâm Sen', , label='hợp tác') KG.add_edge('Trường THPT TP Cao Lãnh' 'Phòng Giáo dục và Đào tạo huyện Cao Lãnh', , label='hợp tác')
KG.add_edge('Trường THPT TP Cao Lãnh' 'Trung tâm ĐT và PT giáo dục nghề nghiệp Đ, T', label='tham gia')
KG.add_edge('Trường THPT TP Cao Lãnh' 'Hội đồng Khoa học và Công nghệ trường TH,
PT TP Cao Lãnh', label='tổ chức')
KG.add_edge('Trường THPT TP Cao Lãnh' 'Trường TC Nghề Thanh Bình', , label='liên kế t')
KG.add_edge('Trường THPT TP Cao Lãnh' 'Trường ĐH Đồng Tháp', , label='đối tác') KG.add_edge('Trường THPT TP Cao Lãnh' 'Trung tâm DVVL ĐT', , label='hỗ trợ') KG.add_edge('Trường THPT TP Cao Lãnh' 'Hội cựu sinh viên trường THPT TP Cao Lãn, h', label='hỗ trợ')
KG.add_edge('Trường THPT TP Cao Lãnh' 'Trường Chuyên NQD', , label='hỗ trợ') KG.add_edge('Trường THPT TP Cao Lãnh' 'Phòng GD&ĐT huyện Thanh Bình', , label='li ên kết')
KG.add_edge('Trường THPT TP Cao Lãnh' 'Lớp 10A1', , label='có')
KG.add_edge('Trường THPT TP Cao Lãnh' 'Võ Thị Thu Liểu', , label='có giáo viên') KG.add_edge('Võ Thị Thu Liểu' 'Trường THPT TP Cao Lãnh', , label='giảng dạy ở') KG.add_edge('Võ Thị Thu Liểu' 'Môn tin học', , label='giảng dạy')
KG.add_edge('Võ Thị Thu Liểu' 'TP Cao Lãnh Tỉnh Đồng Tháp', , label='có địa chỉ ở') KG.add_edge('Võ Thị Thu Liểu' 'học sinh trường THPT TP Cao Lãnh', , label='dạy') KG.add_edge('Võ Thị Thu Liểu' 'Trường ĐH Đồng Tháp', , label='tốt nghiệp từ') KG.add_edge('Võ Thị Thu Liểu','Khoa CNTT', label='trực thuộc')
KG.add_edge('Võ Thị Thu Liểu' 'Lớp 10A1', , label='chủ nhiệm')
KG.add_edge('Võ Thị Thu Liểu' 'Môn Tin học', , label= 'giảng dạy')
KG.add_edge('Võ Thị Thu Liểu' 'Trung tâm DVVL ĐT', , label='là giáo viên thỉnh giảng c ủa')
KG.add_edge('Võ Thị Thu Liểu' 'Trường Chuyên NQD', , label='là giáo viên thỉnh giảng c ủa')
KG.add_edge('Môn Tin học' 'CTR GDPT', , label='là môn tự chọn của')
KG.add_edge('Môn Tin học' 'Võ Thị Thu Liểu', , label='có gv là')
KG.add_edge('Môn Tin học' 'Võ Thị Thu Liểu', , label='được giảng dạy bởi')
KG.add_edge('Lớp 10A1' 'Võ Thị Thu Liểu', , label='có gv chủ nhiệm là')
KG.add_edge('Lớp 10A1' 'Môn Tin học', , label='có học môn')
KG.add_edge('Lớp 10A1' 'Trường THPT TP Cao Lãnh', , label='có 40 HS thuộc')
KG.add_edge('Trường Chuyên NQD' 'Võ Thị Thu Liểu', , label= 'mời gv thỉnh giảng là') KG.add_edge('Trường Chuyên NQD' 'Môn Tin học', , label='có dạy môn')
KG.add_edge('Trường Chuyên NQD' 'Sở GDĐT Đồng Tháp', , label= 'trực thuộc') KG.add_edge('Trường Chuyên NQD' 'Sở GDĐT Đồng Tháp', , label= 'là 1 trong 2 trường chuyên của')
KG.add_edge('Trường Chuyên NQD' 'TP Cao Lãnh Tỉnh Đồng Tháp', , label= 'có địa chỉ ở' )
KG.add_edge('Trung tâm DVVL ĐT' 'TP Cao Lãnh Tỉnh Đồng Tháp', , label= 'có địa chỉ ở' )
KG.add_edge('Trung tâm DVVL ĐT' 'Bộ lao động TB&XH', , label= 'trực thuộc') KG.add_edge('Trung tâm DVVL ĐT' 'Võ Thị Thu Liểu', , label='mời gv thỉnh giảng là') KG.add_edge('Trung tâm DVVL ĐT' 'Môn Tin học', , label= 'có dạy môn')
KG.add_edge('Trường ĐH Đồng Tháp' 'Khoa CNTT', , label='có')
KG.add_edge('Trường ĐH Đồng Tháp' 'TP Cao Lãnh Tỉnh Đồng Tháp', , label='có địa chỉ ở')
# Print the nodes and edges in the knowledge graph print("Nodes:", KG.nodes()) print("Edges:", KG.edges())
# Draw the knowledge graph using matplotlib pos = nx.spring_layout(KG) nx.draw(KG, pos, with_labels=True) edge_labels = {(u, v): d['label'] for u, v, d KG.edges(data=in True)} nx.draw_networkx_edge_labels(KG, pos, edge_labelse_labels)
# DỮ LIỆU VỀ TRƯỜNG THPT TP CAO LÃNH: plt.show() for triple in KG.edges(): triple[if 0]=='Trường THPT TP Cao Lãnh': print(triple)
# Tìm đường đi ngắn nhất giữa 'Trường THPT TP Cao Lãnh'và 'Bộ lao động TB&XH shortest_path = nx.shortest_path(KG, 'Trường THPT TP Cao Lãnh' 'Bộ lao động TB&XH', )
# Print the shortest path print("\n Đường đi ngắn nhất giữa 'Trường THPT TP Cao Lãnh'và 'Bộ lao động TB&XH' :
CÁC KỸ THUẬT SUY DIỄN VÀ LẬP LUẬN
CÁC LUẬT DẪN
Luật là cấu trúc tri thức dùng để liên kết thông tin đã biết với các thông tin khác giúp đưa ra các suy luận, kết luận từ những thông tin đã biết.
Trong hệ thống dựa trên luật, ta thu thập các tri thức lĩnh vực trong một tập và lưu chúng trong cơ sở tri thức của hệ thống.
Việc xử lý các luật trong hệ thống dựa trên các luật được quản lý bằng một module gọi là bộ suy diễn.
Các dạng luật cơ bản: có 7 dạng
IF Bình điện hỏng THEN Xe sẽ không khởi động được
IF Xe không khởi động được THEN Đi bộ
IF Xe không khởi động được AND Hệ thống nhiên liệu tốt THEN Kiểm tra hệ thống điện
IF Xe không khởi động được THEN Đầu tiên hãy kiểm tra hệ thống nhiên liệu, sau đó kiểm tra hệ thống điện
IF Xe nổ AND tiếng giòn THEN Động cơ hoạt động bình thường
IF Sốt cao AND hay ho AND Họng đỏ THEN Viêm họng
IF Là nữ AND Da sáng THEN Nên chọn Xe Honda Lead AND Chọn màu sáng
ĐỒ THỊ LUẬT SUY DIỄN
Đồ thị luật (rule graph) là một dạng đồ thị biểu diễn một tập hợp các luật logic trong lĩnh vực trí tuệ nhân tạo Đồ thị luật cho phép biểu diễn các quan hệ giữa các luật trong một mạng lưới và cho phép áp dụng nhiều luật đồng thời để giải quyết các vấn đề phức tạp.
Mỗi nút trong đồ thị biểu diễn một luật, với các cạnh nối giữa các nút để biểu diễn mối quan hệ giữa các luật Các cạnh có thể biểu diễn rằng một luật phụ thuộc vào các luật khác để có thể thực hiện được Hoặc một luật có thể được áp dụng nếu một số điều kiện được thỏa mãn do mã các luật khác trong đồ thị.
Cách biểu diễn đồ thị luật cơ bản bao gồm các bước sau:
1 Xác định các nút để biểu diễn các luật trong thư viện của bạn.
2 Xác định mối quan hệ giữa các luật để hướng dẫn luật được áp dụng khi nào?
3 Xác định các điều kiện để áp dụng các luật thông qua các đường nối giữa các nút.
4 Thực hiện suy luận bằng cách điều hướng đồ thị và áp dụng các quy tắc biểu diễn các nút và các đường nối với nhau.
Cách biểu diễn đồ thị luật là một trong các công cụ giúp trí tuệ nhân tạo có thể hỗ trợ cho việc suy luận, quyết định, tư vấn và giúp đưa ra những kết quả hiệu quả và chính xác hơn trong lĩnh vực kinh tế, y tế, công nghệ và giáo dục.
Có 3 loại node trên đồ thị luật:
- Node kết luận: Node không có cung đi ra (node A)
- Node lá: Không có cung đi vào (Node Q, D, J)
- Node trung gian: Vừa có cung đi ra vừa có cung đi ra vừa có cung đi vào (Node B, C)
Các nút lá cần phải được cung cấp giá trị đúng hoặc sai Chính giá trị đó kết hợp với đồ thị luật sẽ cho ra kết quả đầu ra là node kết luận.
ĐỒ THỊ LUẬT SUY DIỄN
Giả thuyết từ giá trị các node lá, khi hệ thống thấy giả thuyết của luật khớp với với thông tin trong bộ nhớ, câu kết luận của luật được bổ sung vào bộ nhớ.
Làm việc tốt khi bài toán về bản chất đi thu thập thông tin rồi thấy điều cần suy diễn
Suy diễn tiến cho ra khối lượng lớn các thông tin từ một số thông tin ban đầu Nó sinh ra nhiều thông tin mới
Suy diễn tiến là tiếp cận lý tưởng đối với loại bài toán cần giải quyết các nhiệm vụ như lập kế hoạch, điều hành điều khiển và diễn dịch.
Một nhược điểm chính của hệ thống suy diễn tiến là không cảm nhận được rằng chỉ một vài thông tin là quan trọng Hệ thống hỏi các câu hỏi có thể hỏi mà không biết rằng chỉ một ít câu đã đi đến kết luận được
Hệ thống có thể hỏi cả câu không liên quan Có thể các câu trả lời cũng quan trọng, nhưng làm người dùng lúng túng khi phải trả lời các câu không dính đến chủ đề.
Xác định kết luận trước sau đó xây dựng các nút lá nào liên quan đến kết luận.
Một trong các ưu điểm chính của suy diễn lùi là phù hợp với bài toán đưa ra giả thuyết rồi xem hiệu qủa giả thiết đó có đúng không
Suy diễn lùi tập trung vào đích đã cho Nó tạo ra một loạt câu hỏi chỉ liên quan đến vấn đề đang xét, đến hoàn cảnh thuận tiện đối với người dùng.
Khi suy diễn lùi muốn suy diễn cái gì đó từ các thông tin đã biết, nó chỉ tìm trên một phần của cơ sở tri thức thích đáng đối với bài toán đang xét
Nhược điểm cơ bản của suy diễn này là nó thường tiếp theo dòng suy diễn, thay vì đúng ra phải đúng ở đó mà sang nhánh khác Tuy nhiên có thể dùng nhân tố tin cậy và các luật meta để khắc phục
BIỂU DIỄN ĐỒ THỊ LUẬT SUY DIỄN VÀ LẬP LUẬN TIẾN
Yêu cầu: Hãy cho 10 luật suy diễn trong lĩnh vực làm việc của cá nhân, sau đó vẽ đồ thị luật đó Dùng kỹ thuật lập luận tiến để từ các giá trị của node lá đưa ra giá trị của node kết luận.
# Write a Python Code to implement a forward chaining reasoning of a rule based inferen ce engine of expert system
# Define the rules in the form of a dictionary import networkx nxas import matplotlib.pyplot pltas
'C':'Đạt giải 3 trở lên HSGQG',
'D':'Đạt giải 3 trở lên HSG Tỉnh',
'P': 'Không vi phạm nội qui',
'Q':'Đạt huy chương thể thao',
'S': 'Năng khiếu chơi thể thao',
'T': 'Tập thể thao thường xuyên',
'V': 'Làm việc, nghỉ ngơi khoa học'}
# print(DS[k]) rules = {'rule1' 'antecedent' 'B' 'C' 'consequent' 'A'},: { : [ , ], :
'rule4': {'antecedent' 'G' 'H' 'O'], : [ , , 'consequent' 'N'},: 'rule5': {'antecedent' 'N' 'K' 'I'], : [ , , 'consequent' 'D'},:
# Add triples to the graph
KG.add_edge('R','V',label=" _") pos = nx.spring_layout(KG) nx.draw(KG, pos, with_labels=True) edge_labels = {(u, v): d['label'] for u, v, d KG.edges(data=in True)} nx.draw_networkx_edge_labels(KG, pos, edge_labelse_labels)
# Show the plot plt.show()
# Define the facts or initial state of the system
#facts = {'A': True, 'B': False, 'C': True} facts = { : 'U' True, 'V': True, 'S': True,'T': True, 'E': True, 'F': True, 'P': True, 'H': True, ' M': True ,'L': True, 'K': True, 'J': True}
# Initialize an empty list to store the inferred facts inferred_facts = []
# Hàm kiểm tra xem một quy tắc có thể được áp dụng hay không def check_rule(rule, facts): antecedent = rule['antecedent'] for a antecedent:in a[ ] == : if 0 '!' # check for negation facts.get(a[ :]) != if 1 False: returnFalse else: facts.get(a) != if True: returnFalse returnTrue
# Hàm để áp dụng quy tắc và thêm các dữ kiện được suy luận vào danh sách def apply rule_ (rule, inferred_facts, facts): consequent = rule['consequent'] inferred_facts.append(consequent) facts[consequent] = True
# Tiếp tục lặp cho đến khi không thể suy ra sự kiện mới nào while True: new_fact = False for r rules:in rules[r][if 'consequent'] not in facts and check_rule(rules[r], facts): apply_rule(rules[r], inferred_facts, facts) new_fact = True ifnot new_fact: break
# Print the inferred facts print("Inferred Facts:") print(inferred_facts) for k in inferred_facts:
(k DS):if in print(DS[k])
Kết quả chạy chương trình:
Sức Khỏe tốt Được thi HSG Tỉnh Đạt giải 3 trở lên HSG Tỉnh Đạt giải 3 trở lên HSGQG Đạt huy chương thể thao Đậu ĐH
Vậy với dữ liệu vào là các node lá đều có giá trị đúng là suy ra được các kết luận
G, I, O, R, N, D, C, B, A Đồ thị mô phỏng 10 luật suy diễn:
BIỂU DIỄN ĐỒ THỊ LUẬT SUY DIỄN VÀ LẬP LUẬN LÙI
Yêu cầu: Hãy cho 10 luật suy diễn trong lĩnh vực làm việc của cá nhân, sau đó vẽ đồ thị luật đó Dùng kỹ thuật lập luận lùi (có NOT cho các giá trị tại các node) để từ xác định kết luận trước, sau đó xây dựng các node lá liên quan đến kết luận
#Write a Python Code to implement a backward chaining reasoning of a rule based infere nce engine of expert system
# Define the rules in the form of a dictionary rules = {'rule1' 'antecedent' 'B' 'C': { : [ , , not('W')], 'consequent' 'A'},:
# Define the goal or query to be answered goal = 'A' facts = { : 'B' True, 'N': True,'K': True,'I': True,'J':True, 'W':True}
# Define a function to recursively check if a goal can be satisfied def check_goal(goal, facts): facts.get(goal) == if True: returnTrue for r rules:in print("r:",r) rules[r][if 'consequent'] == goal: print("goal:",goal) print("rule with conseqeunt equal goal:",r) antecedent = rules[r]['antecedent'] print("antecedant of rule equal goal:",antecedent)
(check_goal(a, facts) ifall for a antecedent):in facts[goal] = True returnTrue returnFalse
# Call the check_goal function to solve the query if check_goal(goal, facts): print("The goal '%s' can be satisfied." % goal) else: print("The goal '%s' cannot be satisfied." % goal)
KẾT QUẢ CHẠY CHƯƠNG TRÌNH: r: rule1 goal: A rule with conseqeunt equal goal: rule1 antecedant of rule equal goal: ['B', 'C', False] r: rule1 r: rule2 r: rule3 r: rule4 r: rule5 r: rule6 goal: C rule with conseqeunt equal goal: rule6 antecedant of rule equal goal: ['D', 'J'] r: rule1 r: rule2 r: rule3 r: rule4 r: rule5 goal: D rule with conseqeunt equal goal: rule5 antecedant of rule equal goal: ['N', 'K', 'I'] r: rule1 r: rule2 r: rule3 r: rule4 r: rule5 r: rule6 r: rule7 r: rule8 r: rule9 r: rule10 r: rule11 r: rule2 r: rule3 r: rule4 r: rule5 r: rule6 r: rule7 r: rule8 r: rule9 r: rule10 r: rule11 goal: A rule with conseqeunt equal goal: rule11 antecedant of rule equal goal: ['B', 'C', 'W']
The goal 'A' can be satisfied.
Vậy để kết luận A, khi có các giá trị 'B': True, 'N': True, 'K': True, 'I': True,'J':True, 'W':True thì kết luận A có thể được thỏa mãn.
LẬP LUẬN KHÔNG CHẮC CHẮN - HỆ MYCIN
LUẬT ĐƠN GIẢN
Gọi CF(e) là độ đo chắc chắn của chứng cớ
CF(r) là độ đo chắc chắn của luật suy diễn
Thế thì CF(c) là độ đo chắc chắn của kết luận sẽ được tính bằng công thức:
Công thức này chính là nền tảng cho cơ chế lập luận của MYCIN.
Ví dụ 1: IF thuộc bài THEN kiểm tra đạt 10 điểm CF=0.8
Giả sử: Mức độ CF(thuộc bài)=0.9
CF(kt 10đ)r)* CF(thuộc bài)=0.8*0.9=0.72
Vậy độ tin cậy của kết luận “Kiểm tra đạt 10 điểm” là 72%.
Ví dụ 2: IF giá xăng tăng trong nhiều tháng THEN tháng tới giá xăng tăng CF=0.6 Giả sử: Mức độ CF(xăng tăng nhiều tháng)=0.9
CF(xăng tăng trong tháng tới)= CF(r) * CF(xăng tăng nhiều tháng)
Vậy độ tin cậy của kết luận “xăng tăng trong tháng tới” là 54%.
LUẬT PHỨC TẠP
Trong thực tế chúng ta có thể gặp các luật phức tạp như sau:
Toán tử AND được dùng để liên kết chứng cớ e1 và e2
Lúc bấy giờ ta có: CF (e1 AND e2) = MIN(CF(e1), CF(e2))
Với luật có dạng OR như sau: if (e1 OR e2) then (c)
Thì CF (e1 OR e2) = MAX(CF(e1), CF(e2))
Với luật có dạng AND và OR như sau: if ((e1 AND e2) OR e3) then (c)
Thì CF ((e1 AND e2) OR e3) = MAX(MIN(CF(e1), CF(e2)), CF(e3))
Ngoài ra độ đo chắc chắn có dạng NOT được tính như sau: CF(NOT e) = - CF(e) Sau khi tính được độ đo chắc chắn của chứng cớ liên kết, ta dùng công thức nêu trong mục 5.2.1 để tính CF của kết luận
Ví dụ 1: IF học thuộc bài và giải nhiều bài tập THEN kt 10 điểm CF=0.9 e1 e2 c
Mức độ: CF(e1)=0.8 (thuộc hết nội dung chính)
CF(e2)=0.9 (giải được hết 9/10 bài tập giáo viên giao)
Vậy độ tin cậy của kết luận đạt điểm 10 là 72%.
Ví dụ 2: IF thông minh OR chăm chỉ THEN đậu đại học CF(r)=0.8 e1 e2 c
Mức độ: CF(e1)=0.9 (chuyên gia đánh giá)
CF(e2)=0.8 (chuyên gia đánh giá)
Vậy độ tin cậy của kết luận “đậu đại học” là 72%.
KẾT HỢP NHIỀU LUẬT CÓ CÙNG KẾT LUẬN
Ví dụ: Có hai luật có cùng kết luận như sau:
Luật 1: If(e1) then (c) với CF(r1): độ đo chắc chắn của luật 1
Luật 2: If(e2) then (c) với CF(r2): độ đo chắc chắn của luật 2
Trong lý thuyết xác suất cổ điển ta có thủ tục nhân các độ đo xác suất để kết hợp các chứng cớ độc lập Có thể dùng thủ tục này để kết hợp các kết luận của một số tuỳ ý các luật Với CF(t1), CF(t2) là CF của kết luận của luật 1 và 2, khi CF(t1) và Cf(t2) đều dương thì:
C(tổng) = CF(t1) + CF(t2) – CF(t1) * CF(t2)
Khi CF(t1) và Cf(t2) đều âm thì:
C(tổng) = CF(t1) + CF(t2) + CF(t1) * CF(t2)
Nếu CF(t1) khác dấu với CF(t2) thì:
C(tổng) = (CF(t1) + CF(t2)) / (1 – MIN(ABS(CF(t1)), ABS(CF(t2))))
CHƯƠNG TRÌNH TRIỂN KHAI LẬP LUẬN MYCIN
# MYCIN is a computer program that uses certainty factor (CF) to reason about medical di agnoses The program works by using a set of rules to identify potential diseases, and then calculates the degree of certainty that each disease is present based on the presence or abse nce of certain symptoms.
# Here is a Python code to implement the MYCIN CF reasoning: import random
# Define a set of diseases and symptoms diseases = {
"Flu" "Fever" "Cough" "Sore Throat"},: { , ,
"Pneumonia" "Fever" "Cough" "Shortness of Breath"},: { , ,
"Common Cold" "Runny Nose" "Sneezing": { , }
# Define a set of rules rules = {
# Define a function to calculate the degree of certainty def calculate_cf(symptoms disease, ): cf = 1 for symptom symptoms:in
(disease, symptom) rules:if in cf *= rules[(disease, symptom)] else: cf *= 0.1 return cf
# Define a function to diagnose a disease based on symptoms def diagnose(symptoms): max_cf = 0 max_disease = None for disease diseases:in cf = calculate_cf(symptoms, disease) cf > max_cf:if max_cf = cf max_disease = disease return max_disease, max_cf
# Test the diagnose function symptoms = {"Fever" "Cough", } disease, cf = diagnose(symptoms) print("Symptoms:", symptoms) print("Diagnosis:", disease) print("Certainty Factor:", cf)
LẬP LUẬN MỜ VÀ FUZZY LOGIC CONTROLLER
LẬP LUẬN MỜ
Lập luận mờ (fuzzy logic) là một hệ thống lập luận dựa trên việc áp dụng các thuật toán và phép tính liên quan đến thông tin với độ chính xác không rõ ràng hoặc không thể xác định chính xác.
Trong lập luận mờ, các khái niệm bao gồm các giá trị không rõ ràng, mờ hoặc đôi khi ngược lại với các giá trị rõ ràng và chính xác trong các hệ thống lập luận thông thường. Lập luận mờ giúp mô hình hóa và phân tích các khái niệm không rõ ràng hoặc phức tạp hơn một cách hiệu quả hơn.
Lập luận mờ được ứng dụng trong nhiều lĩnh vực, bao gồm điều khiển tự động, điện tử, máy tính, kinh tế, kỹ thuật và khoa học Ví dụ, trong hệ thống điều khiển tự động, lập luận mờ có thể giúp cải thiện khả năng đáp ứng và ổn định hệ thống, cũng như làm giảm sự phụ thuộc vào các hệ số rời rạc.
Lập luận mờ là một mở rộng của lý thuyết tập hợp mờ và được sử dụng để mô hình hóa các hệ thống trong đó các thuộc tính không phải là tuyệt đối và không thể được phân loại chính xác.
Tập mờ (Fuzzy set) là một tập hợp các phần tử mà mỗi phần tử của tập có một mức độ thuộc về tập đó được xác định bằng giá trị số trong khoảng từ 0 đến 1 Trong tập mờ, một phần tử có thể thuộc hoặc không thuộc tập đó một cách mờ nhạt, thay vì chỉ thuộc hoặc không thuộc.
Một ví dụ về tập mờ là tập "giá cả rẻ" Trong trường hợp này, giá cả của một sản phẩm có thể thuộc vào tập "giá rẻ" ở mức độ từ 0 đến 1, với giá trị 0.0 nghĩa là không rẻ và 1.0 nghĩa là rất rẻ Ví dụ, nếu chúng ta xét sản phẩm Apple iPhone, có giá tiền trên trung bình mức 20 triệu đồng, ta có thể nói rằng giá tiền của sản phẩm này thuộc vào tập "không rẻ" ở mức độ khoảng 0.3 đến 0.5 để một số khách hàng, trong khi đối với một số khác, giá tiền này có thể được xem như "rất đắt" và có độ thuộc thuộc vào tập "không rẻ" ở mức 0.7 đến 0.9.
Tập mờ cũng có thể được áp dụng trong các lĩnh vực khác như điều khiển các hệ thống tự động, khai thác dữ liệu, nhận dạng hình ảnh, hay trong công nghệ chế tạo sản phẩm Với tập mờ, ta có thể xử lý các tình huống không rõ ràng, mờ nhạt và khách quan hơn, giúp cho quyết định trở nên tốt hơn.
Có 3 dạng hàm thành viên trong lập luận mờ: Dạng tăng, giảm và trung bình (hình chuông)
Các luật mờ Fuzzy là các quy tắc phân loại mờ được sử dụng trong lập luận mờ để xử lý các dữ liệu đầu vào có tính chất mờ nhạt hoặc mâu thuẫn Dưới đây là một ví dụ về các luật mờ:
Giả sử chúng ta muốn xác định mức độ đói của một người dựa trên số lượng calo mà họ đang tiêu thụ Ở đây, ta có 3 tập mờ: đói, no và rất no, và các giá trị trong khoảng 0 và 1.
Luật mờ 1: Nếu người đó đã tiêu thụ rất nhiều calo, và món ăn hiện tại mà họ đang ăn không có nhiều calo, thì họ còn đói.
Luật mờ 2: Nếu người đó đang ăn một món ăn có nhiều calo, và thấy no, thì họ rất no.
Luật mờ 3: Nếu người đó có vẻ no, nhưng món ăn mà họ đang ăn làm cho họ thấy đói hơn, thì họ vẫn đói.
Nếu chúng ta có thông tin về số calo tiêu thụ của người đó, thì ta có thể sử dụng các luật mờ để xác định mức độ đói của họ Ví dụ, nếu người đó đã tiêu thụ một lượng calo trung bình, và món ăn hiện tại mà họ đang ăn có nhiều calo, thì theo Luật mờ 2, ta có thể kết luận rằng họ rất no Tuy nhiên, nếu một người đang ăn một món ăn có nhiều calo và cảm thấy đói hơn, theo Luật mờ 3 ta có thể kết luận rằng họ vẫn đói.
Các luật mờ được sử dụng để xử lý các tình huống mâu thuẫn hoặc mờ nhạt, giúp cho quyết định trở nên chính xác và khách quan hơn trong lập luận mờ.
FUZZY LOGIC CONTROLLER
Fuzzy logic controller (FLC) là một hệ thống điều khiển tự động dựa trên lý thuyết lập luận mờ, được sử dụng để điều khiển các hệ thống có tính mờ, không chính xác hoặc khó điều khiển bằng các phương pháp điều khiển truyền thống.
Trong một FLC, các tín hiệu đầu vào được chuyển đến hệ thống điều khiển và được biểu diễn bằng các biến mờ, đồng thời các luật mờ và các quy tắc giám sát được sử dụng để xác định đầu ra của hệ thống.
Các biến mờ được sử dụng để mô hình hóa và xử lý các dữ liệu mờ, ví dụ như nhiệt độ, độ ẩm, áp suất, và các thông số khác Mỗi biến mờ được chia thành các tập mờ, và mỗi tập mờ được đặt tên để đại diện cho một mức độ hoặc trạng thái của biến đó.
Các quy tắc được sử dụng trong FLC thường được xác định bởi các chuyên gia trong lĩnh vực, thông qua kinh nghiệm và hiểu biết sâu sắc về hệ thống được điều khiển Đầu ra cuối cùng của FLC được tính toán bằng cách ước lượng tổng quát của tất cả các luật mờ được kích hoạt.
FLC được ứng dụng rộng rãi trong các lĩnh vực khác nhau như điều khiển robot, điều khiển tàu thủy, điều khiển xe tự lái, điều khiển robot công nghiệp, và nhiều hệ thống khác FLC cung cấp khả năng xử lý các dữ liệu mờ, phức tạp và không chính xác, giúp cho quá trình điều khiển trở nên chính xác và ổn định hơn.
VÍ DỤ CHƯƠNG TRÌNH ĐIỀU KHIỂN TỰ ĐỘNG HỆ THỐNG TƯỚI NƯỚC VÀ BÓN PHÂN DỰA VÀO FUZZY LOGIC CONTROLLER
VÀ BÓN PHÂN DỰA VÀO FUZZY LOGIC CONTROLLER
Yêu cầu: Viết chương trình điều khiển tự động Fuzzy cho một hệ thống tưới tiêu trong nông nghiệp. Ý tưởng: Hệ thống điều khiển lượng nước tưới và lượng phân bón cho cây trồng dựa vào tỉ lệ của các thuộc tính: Nhiệt độ, độ ẩm, độ PH và màu lá.
#2023-04-26-THU LIỂU_FanSpeed_FuzzyLogicCotroller.ipynb
#Write a Python Code for Fuzzy reasoning in Fuzzy Logic Controller Give an application in controlling the Speed of Fan by using the Fuzzy Logic Control
# !pip install scikit-fuzzy import numpy npas import skfuzzy fuzzas from skfuzzy import control ctrlas
# Define the inputs and outputs of the Fuzzy Logic Controller
ND = ctrl.Antecedent(np.arange( , 0 101 1, ), 'Nhiệt độ')
DA = ctrl.Antecedent(np.arange( , 0 101 1, ), 'Độ ẩm')
PH = ctrl.Antecedent(np.arange( , 0 101 1, ), 'Độ PH')
LA = ctrl.Antecedent(np.arange( , 0 101 1, ), 'Màu lá')
LNUOC = ctrl.Consequent(np.arange( , 0 101 1, ), 'Lượng nước')
LPHAN = ctrl.Consequent(np.arange( , 0 101 1, ), 'Lượng phân')
# Define the membership functions for the inputs and outputs
ND['Thấp'] = fuzz.trimf(ND.universe, [0, 0, 50])
ND['Trung bình'] = fuzz.trimf(ND.universe, [ , , 0 50 100])
ND['Cao'] = fuzz.trimf(ND.universe, [50, 100, 100])
DA['Thấp'] = fuzz.trimf(DA.universe, [0, 0, 50])
DA['Trung bình'] = fuzz.trimf(DA.universe, [ , , 0 50 100])
DA['Cao'] = fuzz.trimf(DA.universe, [5, 100, 100])
PH['Thấp'] = fuzz.trimf(PH.universe, [0, 0, 50])
PH['Trung bình'] = fuzz.trimf(PH.universe, [ , , 0 50 100])
PH['Cao'] = fuzz.trimf(PH.universe, [50, 100, 100])
LA['Nhạt'] = fuzz.trimf(LA.universe, [0, 0, 50])
LA['Trung bình'] = fuzz.trimf(LA.universe, [ , , 0 50 100])
LA['Đậm'] = fuzz.trimf(LA.universe, [51, 100, 100])
LNUOC['Ít'] = fuzz.trimf(LNUOC.universe, [0, 0, 50])
LNUOC['Trung bình'] = fuzz.trimf(LNUOC.universe, [ , , 0 50 100])
LNUOC['Nhiều'] = fuzz.trimf(LNUOC.universe, [50, 100, 100])
LPHAN['Ít'] = fuzz.trimf(LPHAN.universe, [0, 0, 50])
LPHAN['Trung bình'] = fuzz.trimf(LPHAN.universe, [ , , 0 50 100])
LPHAN['Nhiều'] = fuzz.trimf(LPHAN.universe, [50, 100, 100])
# Define the rules for the Fuzzy Logic Controller rule1 = ctrl.Rule(ND['Cao'] & DA['Thấp'], LNUOC['Nhiều']) rule2 = ctrl.Rule(ND['Cao'] & DA['Cao'], LNUOC['Trung bình']) rule3 = ctrl.Rule(ND['Cao'] & DA['Trung bình'], LNUOC['Trung bình']) rule4 = ctrl.Rule(ND['Trung bình'] & DA['Trung bình'], LNUOC['Trung bình']) rule5 = ctrl.Rule(ND['Trung bình'] & DA['Thấp'], LNUOC['Nhiều']) rule6 = ctrl.Rule(ND['Trung bình'] & DA['Cao'], LNUOC['Ít']) rule7 = ctrl.Rule(ND['Thấp'] & DA['Cao'],LNUOC[ ])'Ít' rule8 = ctrl.Rule(ND['Thấp'] & DA['Trung bình'],LNUOC['Trung bình']) rule9 = ctrl.Rule(ND['Thấp'] & DA['Thấp'],LNUOC['Trung bình']) rule10 = ctrl.Rule(PH['Cao'] & LA['Trung bình'], LPHAN['Trung bình']) rule11 = ctrl.Rule(PH['Cao'] & LA['Đậm'], LPHAN['Ít']) rule12 = ctrl.Rule(PH['Cao'] & LA['Nhạt'], LPHAN['Trung bình']) rule13 = ctrl.Rule(PH['Trung bình'] & LA['Trung bình'], LPHAN['Trung bình']) rule14 = ctrl.Rule(PH['Trung bình'] & LA['Đậm'], LPHAN['Ít']) rule15 = ctrl.Rule(PH['Trung bình'] & LA['Nhạt'], LPHAN['Nhiều']) rule16 = ctrl.Rule(PH['Thấp'] & LA['Trung bình'] , LPHAN['Trung bình']) rule17 = ctrl.Rule(PH['Thấp'] & LA['Đậm'] , LPHAN['Ít']) rule18 = ctrl.Rule(PH['Thấp'] & LA['Nhạt'] ,LPHAN['Nhiều'])
# Create the Fuzzy Logic Controller nuoc_ctrl = ctrl.ControlSystem([rule1, rule2, rule3, rule4, rule5, rule6, rule7, rule8, rule9] ) phan_ctrl = ctrl.ControlSystem([rule10, rule11, rule12, rule13, rule14, rule15, rule16, rul e17, rule18])
LNUOC_sim = ctrl.ControlSystemSimulation(nuoc_ctrl)
LPHAN_sim = ctrl.ControlSystemSimulation(phan_ctrl)
# Pass input values to the simulation
LNUOC_sim.input['Nhiệt độ'] = 90
LNUOC_sim.input['Độ ẩm'] = 10
LPHAN_sim.input['Độ PH'] = 5
LPHAN_sim.input['Màu lá'] = 5
# Compute the output value of the simulation
# Print the output value print("Lượng nước cần tưới là: ", LNUOC_sim.output['Lượng nước'], "%") print("Lượng phân cần bón là: ", LPHAN_sim.output['Lượng phân'], "%")
Lượng nước cần tưới là: 67.1155668149613 %
Lượng phân cần bón là: 73.82352941176474 %
4 VÍ DỤ CHƯƠNG TRÌNH ĐIỀU KHIỂN TỰ ĐỘNG HỆ THỐNG BƠM NƯỚC VỚI CHỈ SỐ 3 BIẾN BẤT KỲ NHẬP TỪ BÀN PHÍM
# 2023-05-05-FuzzyController_DieuKhienBom.ipynb import numpy npas import skfuzzy fuzzas from skfuzzy import control ctrlas
### Dinh nghia 3 bien ngon ngu (linguistic variables) ho_nuoc = ctrl.Antecedent(np.arange( , , 0 2 0.1), 'ho_nuoc') gieng_nuoc = ctrl.Antecedent(np.arange( , , 0 10 0.1), 'gieng_nuoc') toc_do_bom = ctrl.Consequent(np.arange( , , 0 30 0.1), 'toc_do_bom')
## Cac tap mo cho bien x tuc la ho nuoc tren cao (be) ho_nuoc['day'] = fuzz.trimf(ho_nuoc.universe, [0, 2, 2]) # Hồ đầy ho_nuoc['lung'] = fuzz.trimf(ho_nuoc.universe, [0, 1, 2]) # Hồ lưng ho_nuoc['can'] = fuzz.trimf(ho_nuoc.universe, [0, 0, 2]) # Hồ cạn
## Cac tap mo cho bien y tuc la gieng nuoc o duoi dat gieng_nuoc['cao'] = fuzz.trimf(gieng_nuoc.universe, [ , , ]) 0 10 10 # Nước giếng cao gieng_nuoc['vua'] = fuzz.trimf(gieng_nuoc.universe, [ , , ]) 0 5 10 # Nước giếng vừa gieng_nuoc['it'] = fuzz.trimf(gieng_nuoc.universe, [ , , ]) 0 0 10 # Nước giếng ít
## Cac tap mo cho bien z toc do bom, rpm (round per minute) toc_do_bom['vua'] = fuzz.trimf(toc_do_bom.universe, [0, 15, 30]) # Tốc độ vừa toc_do_bom['lau'] = fuzz.trimf(toc_do_bom.universe, [0, 30, 30]) # Tốc độ lâu toc_do_bom['hoi_lau'] = fuzz.trimf(toc_do_bom.universe, [ , , 0 20 100]) # Tốc độ hơi lâu def get_pump_speed_control_rules(): # Cac luat mo bieu dien toc do quat """ rule0a = ctrl.Rule( ho_nuoc['day'] & gieng_nuoc['cao'], toc_do_bom['khong-bom']
) rule0b = ctrl.Rule( ho_nuoc['day'] & gieng_nuoc['vua'], toc_do_bom['khong-bom']
) rule0c = ctrl.Rule( ho_nuoc['day'] & gieng_nuoc['it'], toc_do_bom['khong-bom']
) rule0d = ctrl.Rule( ho_nuoc['lung'] & gieng_nuoc['it'], toc_do_bom['khong-bom']
) rule0e = ctrl.Rule( ho_nuoc['can'] & gieng_nuoc['it'], toc_do_bom['khong-bom']
""" rule1 = ctrl.Rule( ho_nuoc['lung'] & gieng_nuoc['cao'], toc_do_bom['vua']
) rule2 = ctrl.Rule( ho_nuoc['can'] & gieng_nuoc['cao'], toc_do_bom['lau']
) rule3 = ctrl.Rule( ho_nuoc['lung'] & gieng_nuoc['vua'], toc_do_bom['vua']
) rule4 = ctrl.Rule( ho_nuoc['can'] & gieng_nuoc['vua'], toc_do_bom['hoi_lau']
# rule0a, rule0b, rule0c, rule0d, rule0e, rule1, rule2, rule3, rule4
] pump_ctrl = ctrl.ControlSystem( get_pump_speed_control_rules()
) input('Nhấn Enter để tiến hành các luật!') speed = ctrl.ControlSystemSimulation(pump_ctrl) ho_nuoc.view()
## Trong truong hop nay x=x0= 1m in_hn = input("Nhap do cao cua nuoc trong ho:") speed.input['ho_nuoc'] = int(in_hn) gieng_nuoc.view()
## Trong truong hop nay la y=y0=3m in_gn = input("Nhap do cao cua nuoc trong gieng:") speed.input['gieng_nuoc'] = int(in_gn) toc_do_bom.view()
## Dua tren x=x0=1 m va y=y0=3m tya tinh toc do speed.compute() input("Nhấn phím bất kỳ để kết thúc!") print("toc_do_bom (RPM)", f"{speed.output['toc_do_bom' "]} ) toc_do_bom.view(sim=speed)
Nhấn Enter để tiến hành các luật!
Nhap do cao cua nuoc trong ho:1
Nhap do cao cua nuoc trong gieng:3
Nhấn phím bất kỳ để kết thúc! toc_do_bom (RPM) 16.572963604852713