pycityagent 2.0.0a52__cp311-cp311-macosx_11_0_arm64.whl → 2.0.0a54__cp311-cp311-macosx_11_0_arm64.whl

pycityagent/cityagent/memory_config.py

@@ -17,24 +17,22 @@ agent_skills = list(sorted_clipped_skills.mean(axis=0))
 
 def memory_config_societyagent():
     EXTRA_ATTRIBUTES = {
-        "city": "New York",
-        # 需求信息
         "type": (str, "citizen"),
-        "needs": (
-            dict,
-            {
-                "hungry": random.random(),  # 饥饿感
-                "tired": random.random(),  # 疲劳感
-                "safe": random.random(),  # 安全需
-                "social": random.random(),  # 社会需求
-            },
-            True,
-        ),
+        "city": (str, "New York", True),
+
+        # Needs Model
+        "hunger_satisfaction": (float, random.random(), True),  # 饥饿满意度
+        "energy_satisfaction": (float, random.random(), True),  # 精力满意度  
+        "safety_satisfaction": (float, random.random(), True),  # 安全满意度
+        "social_satisfaction": (float, random.random(), True),  # 社交满意度
         "current_need": (str, "none", True),
+
+        # Plan Behavior Model
         "current_plan": (list, [], True),
         "current_step": (dict, {"intention": "", "type": ""}, True),
         "execution_context": (dict, {}, True),
         "plan_history": (list, [], True),
+
         # cognition
         "emotion": (
             dict,
@@ -46,25 +44,25 @@ def memory_config_societyagent():
                 "anger": 5,
                 "surprise": 5,
             },
-            True,
+            False,
         ),
         "attitude": (dict, {}, True),
         "thought": (str, "Currently nothing good or bad is happening", True),
         "emotion_types": (str, "Relief", True),
-        "incident": (list, [], True),
-        "city": (str, "Texas", True),
+
+        # economy
         "work_skill": (
             float,
             random.choice(agent_skills),
             True,
-        ),  # 工作技能, 即每小时的工资
-        "tax_paid": (float, 0.0, True),  # 纳税
-        "consumption_currency": (float, 0.0, True),  # 月消费
+        ),  # work skill
+        "tax_paid": (float, 0.0, True),  # tax paid
+        "consumption_currency": (float, 0.0, True),  # consumption
         "goods_demand": (int, 0, True),
         "goods_consumption": (int, 0, True),
         "work_propensity": (float, 0.0, True),
         "consumption_propensity": (float, 0.0, True),
-        "income_currency": (float, 0.0, True),  # 月收入
+        "income_currency": (float, 0.0, True),  # monthly income
         "to_income": (float, 0.0, True),
         "to_consumption_currency": (float, 0.0, True),
         "firm_id": (int, 0, True),
@@ -79,23 +77,25 @@ def memory_config_societyagent():
         "forward": (int, 0, True),
         "depression": (float, 0.0, True),
         "ubi_opinion": (list, [], True),
-        # social
-        "friends": (list, [], True),  # 好友列表
-        "relationships": (dict, {}, True),  # 与每个好友的关系强度
-        "relation_types": (dict, {}, True),
-        "chat_histories": (dict, {}, True),  # 所有聊天历史记录
-        "interactions": (dict, {}, True),  # 所有互动记录
-        "to_discuss": (dict, {}, True),
-        # economy
         "working_experience": (list, [], True),
         "work_hour_month": (float, 160, True),
         "work_hour_finish": (float, 0, True),
+
+        # social
+        "friends": (list, [], True),  # friends list
+        "relationships": (dict, {}, True),  # relationship strength with each friend
+        "relation_types": (dict, {}, True),
+        "chat_histories": (dict, {}, True),  # all chat histories
+        "interactions": (dict, {}, True),  # all interaction records
+        "to_discuss": (dict, {}, True),
+
         # mobility
         "environment": (str, "The environment outside is good", True),
+        "number_poi_visited": (int, 1, True),
     }
 
     PROFILE = {
-        "name": random.choice(
+        "name": (str,random.choice(
             [
                 "Alice",
                 "Bob",
@@ -124,13 +124,13 @@ def memory_config_societyagent():
                 "Yvonne",
                 "Zack",
             ]
-        ),
-        "gender": random.choice(["male", "female"]),
-        "age": random.randint(18, 65),
-        "education": random.choice(
+        ), True),
+        "gender": (str, random.choice(["male", "female"]), True),
+        "age": (int, random.randint(18, 65), True),
+        "education": (str, random.choice(
             ["Doctor", "Master", "Bachelor", "College", "High School"]
-        ),
-        "skill": random.choice(
+        ), True),
+        "skill": (str, random.choice(
             [
                 "Good at problem-solving",
                 "Good at communication",
@@ -138,8 +138,8 @@ def memory_config_societyagent():
                 "Good at teamwork",
                 "Other",
             ]
-        ),
-        "occupation": random.choice(
+        ), True),
+        "occupation": (str, random.choice(
             [
                 "Student",
                 "Teacher",
@@ -151,16 +151,16 @@ def memory_config_societyagent():
                 "Athlete",
                 "Other",
             ]
-        ),
-        "family_consumption": random.choice(["low", "medium", "high"]),
-        "consumption": random.choice(["sightly low", "low", "medium", "high"]),
-        "personality": random.choice(
+        ), True),
+        "family_consumption": (str, random.choice(["low", "medium", "high"]), True),
+        "consumption": (str, random.choice(["sightly low", "low", "medium", "high"]), True),
+        "personality": (str, random.choice(
             ["outgoint", "introvert", "ambivert", "extrovert"]
-        ),
+        ), True),
         "income": "0",
         "currency": random.randint(1000, 100000),
-        "residence": random.choice(["city", "suburb", "rural"]),
-        "race": random.choice(
+        "residence": (str, random.choice(["city", "suburb", "rural"]), True),
+        "race": (str, random.choice(
             [
                 "Chinese",
                 "American",
@@ -172,13 +172,13 @@ def memory_config_societyagent():
                 "Russian",
                 "Other",
             ]
-        ),
-        "religion": random.choice(
+        ), True),
+        "religion": (str, random.choice(
             ["none", "Christian", "Muslim", "Buddhist", "Hindu", "Other"]
-        ),
-        "marital_status": random.choice(
+        ), True),
+        "marital_status": (str, random.choice(
             ["not married", "married", "divorced", "widowed"]
-        ),
+        ), True),
     }
 
     BASE = {

pycityagent/cityagent/message_intercept.py

@@ -0,0 +1,99 @@
+import asyncio
+
+from pycityagent.llm import LLM
+from pycityagent.message import MessageBlockBase, MessageBlockListenerBase
+
+
+async def check_message(
+    from_uuid: str, to_uuid: str, llm_client: LLM, content: str
+) -> bool:
+    """
+    使用LLM检查消息是否合规
+    返回: (是否合规, from_uuid, to_uuid)
+    """
+    print(f"\n检查消息: {from_uuid} -> {to_uuid}: {content}")
+
+    prompt = f"""
+        请判断以下消息是否具有情绪煽动性：
+        发送者ID: {from_uuid}
+        接收者ID: {to_uuid}
+        消息内容: {content}
+        
+        如果消息具有情绪煽动性，请返回 False；如果消息正常，请返回 True。
+        """
+
+    if "test" in content.lower():
+        is_valid = False
+    else:
+        is_valid = True
+    print(f"消息检查结果: {'合规' if is_valid else '不合规'}")
+    return is_valid
+
+
+class EdgeMessageBlock(MessageBlockBase):
+    async def forward(  # type:ignore
+        self,
+        from_uuid: str,
+        to_uuid: str,
+        msg: str,
+        black_list: list[tuple[str, str]],
+    ):
+        if (from_uuid, to_uuid) in set(black_list):
+            # 可选同时返回入队的信息(False,err) 如果只返回bool值则默认报错信息入队
+            return False
+        else:
+            is_valid = await check_message(
+                from_uuid=from_uuid,
+                to_uuid=to_uuid,
+                llm_client=self.llm,
+                content=msg,
+            )
+            if not is_valid:
+                # 直接添加即可 在框架内部的异步锁保证不会冲突
+                black_list.append((from_uuid, to_uuid))
+            return is_valid
+
+
+class PointMessageBlock(MessageBlockBase):
+    async def forward(  # type:ignore
+        self,
+        from_uuid: str,
+        to_uuid: str,
+        msg: str,
+        violation_counts: dict[str, int],
+        black_list: list[tuple[str, str]],
+    ):
+        if (from_uuid, to_uuid) in set(black_list):
+            # 可选同时返回入队的信息(False,err) 如果只返回bool值则默认报错信息入队
+            return False
+        else:
+            # violation count在框架内自动维护 这里不用管
+            is_valid = await check_message(
+                from_uuid=from_uuid,
+                to_uuid=to_uuid,
+                llm_client=self.llm,
+                content=msg,
+            )
+            if not is_valid and violation_counts[from_uuid] >= 3 - 1:
+                # 直接添加即可 在框架内部的异步锁保证不会冲突
+                black_list.append((from_uuid, to_uuid))
+            return is_valid
+
+
+class MessageBlockListener(MessageBlockListenerBase):
+    def __init__(
+        self, save_queue_values: bool = False, get_queue_period: float = 0.1
+    ) -> None:
+        super().__init__(save_queue_values, get_queue_period)
+
+    async def forward(
+        self,
+    ):
+        while True:
+            if self.has_queue:
+                value = await self.queue.get_async()  # type: ignore
+                if self._save_queue_values:
+                    self._values_from_queue.append(value)
+                print(f"get `{value}` from queue")
+                # do something with the value
+            await asyncio.sleep(self._get_queue_period)

pycityagent/cityagent/nbsagent.py

@@ -9,14 +9,11 @@ from pycityagent.economy import EconomyClient
 from pycityagent.llm.llm import LLM
 from pycityagent.memory import Memory
 from pycityagent.message import Messager
-from pycityagent.tools import ExportMlflowMetrics
 
 logger = logging.getLogger("pycityagent")
 
 
 class NBSAgent(InstitutionAgent):
-    export_metrics = ExportMlflowMetrics(log_batch_size=3)
-
     def __init__(
         self,
         name: str,
@@ -60,15 +57,13 @@ class NBSAgent(InstitutionAgent):
 
     async def forward(self):
         if await self.month_trigger():
-            citizens = await self.memory.get("citizens")
-            while True:
-                agents_forward = await self.gather_messages(citizens, "forward")
-                if np.all(np.array(agents_forward) > self.forward_times):
-                    break
-                await asyncio.sleep(1)
+            citizens = await self.memory.status.get("citizens")
+            agents_forward = []
+            if not np.all(np.array(agents_forward) > self.forward_times):
+                return
             work_propensity = await self.gather_messages(citizens, "work_propensity")
             working_hours = np.mean(work_propensity) * self.num_labor_hours
-            firm_id = await self.memory.get("firm_id")
+            firm_id = await self.memory.status.get("firm_id")
             price = await self.economy_client.get(firm_id, "price")
             prices = await self.economy_client.get(self._agent_id, "prices")
             initial_price = prices[0]
@@ -116,23 +111,5 @@ class NBSAgent(InstitutionAgent):
             self.forward_times += 1
             for uuid in citizens:
                 await self.send_message_to_agent(
-                    uuid, f"nbs_forward@{self.forward_times}"
-                )
-
-            metrics = {
-                "nominal_gdp": nominal_gdp,
-                "working_hours": working_hours,
-                "price": price,
-                "depression": depression,
-                "consumption": consumption_currency,
-                "income": income_currency,
-            }
-            for k, v in metrics.items():
-                await self.export_metrics(
-                    metric={
-                        "key": k,
-                        "value": v,
-                        "step": self.forward_times,
-                    },
-                    clear_cache=True,
+                    uuid, f"nbs_forward@{self.forward_times}", "economy"
                 )