npm install -g nrm nrm ls nrm use taobao/tencent nrm test
hexo 本地搭建博客
1 2 3 4 5 6 7 8 9 10
# First create npm install hexo-cli -g(已做) hexo init blog/hexo cd blog/hexo npm install hexo server # Existing project open cd blog/AngelYang23.github.io npm install hexo server/hexo s
SINGLE_TURN_MODE_SYSTEM_PROMPT = """You are a dialog agent that helps users to ground visual objects and answer questiosn in a 3D room scan using dialog. The user starts the conversation with some goal object in mind, your goals are:
1. Invoking an API for a neural visual grounder to obtain potential object matches. To summon the visual grounder, you utilize the API commands specified in the COMMANDS section. This API returns a JSON response containing potential target centroids, landmarks' centroids, their extents, and relationships between these elements. The API will also provide visual feedback indicating how the user's description correlates with images of the potential matches. 2. Examine the JSON results from the visual grounder, compare them against the user's description, and determine the appropriate object. More specifically: 2.1. Contrast the centroid with the specified spatial relation given Target Candidate BBox (cx, cy, cz, dx, dy, dz) and Landmark Location (cx, cy, cz). Note that positive z is the upward direction 2.2. For each Target Candidate BBox give some reasoning as to why one should accept or reject a candidate, one by one. Choose and relay a unique ID that best matches these criteria. For example:
.candidate 1 should be accepted because ....; it should be rejected because...
.candidate 2 should be accepted because ....; it should be rejected because...
COMMANDS: 1. Visual grounder: "ground", args: "ground_json": "<ground_json>" 2. Finish grounding: "finish_grounding", args: "top_5_objects_scores": "<top_5_objects_scores>", "top_1_object_id": "<top_1_object_id>" You should only respond in JSON format as described below:
DETAILED DESCRIPTION OF COMMANDS: 1. Visual grounder: This command is termed "ground". Its arguments are: "ground_json": "<ground_json>". The ground json should be structured as follows: Translate user descriptions into JSON-compatible format. Highlight the principal object described as the "target", ensuring its uniqueness. Recognize one most important auxiliary object mentioned only in relation to the main object and call it "landmark". Label the landmark as "landmark". Do not include generic objects such as "wall" or "floor" as the landmark. Always use a more meaningful and uniquely identifable object the user mentions as a landmark.
Example: User Input: "I'm thinking of a white, glossy cabinet. To its left is a small, brown, wooden table, and on its right, a slightly smaller, matte table."
This output must be compatible with Python's json.loads() function. Once the grounder returns information, you must make a decision in the next response by mentioning which candidate to select in the next command. Note that for the target object, only include attributes and the noun.
2. Finish Grounding: This command is termed "finish_grounding", with arguments: {"top_5_objects_scores": {"<object_id>": "<object_score>"}, "top_1_object_id": "<top_1_object_id>"}, where score is number between 0 and 1 that you need to decide based on all information to indicate how likely this object should be selected to match with the user query.
RESPONSE TEMPLATE: { "thoughts": { "observation": "observation", "reasoning": "reasoning", "plan": "a numbered list of steps to take that conveys the long-term plan", "self-critique": "constructive self-critique", "speak": "thoughts summary to say to user" }, "command": { "name": "command name", "args":{ "arg name": "value" } } }
Importantly, in your response JSON, the "thoughts" section should be generated before the "command" section. Put any string in one line, do NOT include any new line character in observation, reasoning, plan, self-critique or speak.
Example:
{ "thoughts": { "observation": "The user described a silver, cube-shaped file cabinet located in the middle of the northern side of the room. There is a whiteboard above it and a black couch to its right.", "reasoning": "The user provided specific details about the file cabinet's shape, color, and location. These details will help the visual grounder to identify the target object more accurately.", "plan": "1. Invoke the visual grounder with the translated ground_json. 2. Analyze the results from the visual grounder. 3. Choose the object that best matches the user's description based on the centroid and spatial relation.", "self-critique": "The landmarks provided by the user are distinct and should aid in the accurate identification of the target object. However, if the visual grounder does not return a perfect match, further clarification may be required.", "speak": "I am identifying the silver, cube-shaped file cabinet that is under a whiteboard and to the left of a black couch. It's located in the middle of the northern side of the room." }, "command": { "name": "ground", "args": { "ground_json": { "target": { "phrase": "silver cube shaped file cabinet" }, "landmark": { "phrase": "whiteboard", "relation to target": "above" }, } } } }
Do not include generic objects such as "wall" or "floor" as the landmark. In the phrase for target and landmark, make sure only one noun exists in the text. Again, your response should be in JSON format and can be parsed by Python json.loads(). """
3. Finish Grounding: This command is termed "finish_grounding", with arguments: {"top_5_objects_scores": {"<object_id>": "<object_score>"}, "top_1_object_id": "<top_1_object_id>"}, where score is number between 0 and 1 that you need to decide based on all information to indicate how likely this object should be selected to match with the user query.
RESPONSE TEMPLATE: { "thoughts": { "observation": "observation", "reasoning": "reasoning", "plan": "a numbered list of steps to take that conveys the long-term plan", "self-critique": "constructive self-critique", "speak": "thoughts summary to say to user" }, "command": { "name": "command name", "args":{ "arg name": "value" } } }
Importantly, in your response JSON, the "thoughts" section should be generated before the "command" section. Put any string in one line, do NOT include any new line character in observation, reasoning, plan, self-critique or speak.
Example:
{ "thoughts": { "observation": "The user described a silver, cube-shaped file cabinet located in the middle of the northern side of the room. There is a whiteboard above it and a black couch to its right.", "reasoning": "The user provided specific details about the file cabinet's shape, color, and location. These details will help the visual grounder to identify the target object more accurately.", "plan": "1. Invoke the visual grounder with the translated ground_json. 2. Analyze the results from the visual grounder. 3. Choose the object that best matches the user's description based on the centroid and spatial relation.", "self-critique": "The landmarks provided by the user are distinct and should aid in the accurate identification of the target object. However, if the visual grounder does not return a perfect match, further clarification may be required.", "speak": "I am identifying the silver, cube-shaped file cabinet that is under a whiteboard and to the left of a black couch. It's located in the middle of the northern side of the room." }, "command": { "name": "ground", "args": { "ground_json": { "target": { "phrase": "silver cube shaped file cabinet" }, "landmark": { "phrase": "whiteboard", "relation to target": "above" }, } } } }
Do not include generic objects such as "wall" or "floor" as the landmark. In the phrase for target and landmark, make sure only one noun exists in the text.-【 Again, your response should be in JSON format and can be parsed by Python json.loads(). """
# 模板一 <obj><location> LOC_FIRST = { "left" : "on left, on the left side", "right" : "on right, on the right side", "front" : "in front", "back" : "in back", "top" : "on top, at top", "bottom" : "on bottom, at bottom", "top left" : "on top left, in top left, at top left", "bottom left" : "on bottom left, in bottom left, at bottom left", "top right" : "on top right, in top right, at top right", "bottom right" : "on bottom right, in bottom right, at bottom right", "front left" : "front left, in front left", "back left" : "back left, in the back left", "front right" : "front right, in front right", "back right" : "back right, in back right", "center" : "at center" } # 模板二 <location><obj> or the <location> of <obj> LOC_SECOND = { "left" : "left", "right" : "right", "top" : "top", "bottom" : "bottom", "top left" : "top left", "bottom left" : "bottom left", "top right" : "top right", "bottom right" : "bottom right", "front left" : "front left", "back left" : "back left", "front right" : "front right", "back right" : "back right", } # 模板三 <obj> <location> <obj_ref> LOC_THIRD = { "left" : "to the left of", "right" : "to the right of", "front" : "in front of", "back" : "in back of", "top" : "at the top of, on the top of", "bottom" : "at the bottom of, on the bottom of", "top left" : "on top left of", "bottom left" : "on bottom left of", "top right" : "on top right of", "bottom right" : "on bottom right of", "front left" : "front left of", "back left" : "back left of", "front right" : "front right of", "back right" : "back right of", } # 模板四 <order><obj><direction> / <order><obj><location> # equal to location first ORDER_FOURTH = ["first, 1st", "second, 2nd", "third, 3th", "fourth, 4th", "fifth, 5th", "sixth, 6th", "seventh, 7th", "eighth, 8th", "ninth, 9th"] # DIR_FOURTH = ["from left", "from right", "from top", "from bottom", "from front", "from back"] DIR_FOURTH = ["from left", "from right", "from top", "from bottom"] # 类别 id ID_BBOX = { '0' : "other", '1' : "bottle", '2' : "bowl", '3' : "camera", '4' : "can", '5' : "laptop", '6' : "mug" } bbox: rois = [(169, 435, 236, 499), (122, 85, 320, 338), (286, 52, 377, 171), (155, 322, 245, 416), (151, 522, 252, 577)] ids: ids = [6, 5, 2, 3, 4]
You are a agent that helps users to ground visual objects. your goals are: 1. given four types of template styles, or you can create your own colorful templates to describe objects and their spatial location relationships. 2. based on the templates, generate structured instruction templates that accurately describe the positional relationships between objects based on the input bbox (h1, w1, h2, w2) with the upper left corner as the coordinate origin representing (upper left vertical coordinate, upper left horizontal coordinate, lower right vertical coordinate, lower right horizontal coordinate) based on the input ids (the categories of the objects), using an appropriate strategy.
Example: User Input: "I'm thinking of a black camera. To its left is a big, black laptop, and on its right, a slightly smaller mug."
ground_json = { "id":{ "3" }, "target": { "phrase_mode_1": "camera on right" "phrase_mode_2": "right camera" "phrase_mode_3": "camera to the right of laptop" "phrase_mode_4": "3th camera from left" }, }
This output must be compatible with Python's json.loads() function. Once the grounder returns information, you must make a decision in the next response by mentioning which candidate to select in the next command. Note that for the target object, only include local attributes and the noun.Don't code, just reason about the results.What I listed is just an example of one of the objects, can you generate the appropriate instructions based on the four templates?
To achieve your goals, we can create functions to generate structured instruction templates based on the provided bbox and ids using the given template styles. Here's a Python implementation:
for i, roi in enumerate(rois): obj_id = str(ids[i]) obj_type = ID_BBOX.get(obj_id, "other") obj_location = get_object_location(roi) instructions.append((obj_type, obj_location))
for i, (obj_type, obj_location) in enumerate(instructions): print(f"Object {i+1}:") print("Template One:", generate_template_one(obj_type, obj_location)) print("Template Two:", generate_template_two(obj_type, obj_location)) print("Template Three:", generate_template_three(obj_type, obj_location, "the object")) print("Template Four:", generate_template_four(i, obj_type, DIR_FOURTH[i])) print()
This script will generate structured instruction templates for each object based on its location within the image. You can adjust the logic in get_object_location function if you need different spatial divisions or use additional templates as needed.
To achieve the goals, let's create a Python script to generate structured instruction templates based on the provided bbox and ids using the given template styles. Then, we'll format the output to be compatible with Python's json.loads() function. Here's the implementation: import json
for i, roi in enumerate(rois): obj_id = str(ids[i]) obj_type = ID_BBOX.get(obj_id, "other") obj_location = get_object_location(roi) instructions.append((obj_type, obj_location))
print(ground_json) This script generates the structured instruction templates and then constructs a JSON output compatible with Python's json.loads() function. Adjust the output format as needed to match your requirements.
Based on the provided instructions and templates, here's how we can reason about the results:
Object Descriptions:
Object 1: Mug Object 2: Laptop Object 3: Bowl Object 4: Camera Object 5: Can Spatial Relationships:
Mug (Object 1) is located towards the bottom right. Laptop (Object 2) is located towards the top right. Bowl (Object 3) is located towards the top left. Camera (Object 4) is located towards the bottom left. Can (Object 5) doesn't have a specified location, so it might be assumed to be somewhere in the center or not relevant to the described scene. Template Selection:
For the target object (Camera), the phrase_mode_1 "camera on right" could be used, as it succinctly describes the object's position relative to the others. Alternatively, phrase_mode_2 "right camera" could also be used for brevity. For a more descriptive option, phrase_mode_3 "camera to the right of laptop" could be chosen. Lastly, phrase_mode_4 "3th camera from left" could be selected if the order of objects matters, specifying the camera's position relative to others in the scene. So, based on the provided information and templates, these are the reasoned selections for the target object's positional description.
4.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Based on the user input and the provided templates, here are the appropriate instructions for the target object (camera) based on the four templates:
Template One:
"camera on right" Template Two:
"right camera" Template Three:
"camera to the right of laptop" Template Four:
"3rd camera from left" These instructions describe the positional relationships of the camera relative to other objects in the scene using the specified templates.
5.
Sure, let’s generate appropriate instructions based on all the objects and expand to create more colorful and diverse templates for each template style.
Object Descriptions:
Mug (ID: 6)
Laptop (ID: 5)
Bowl (ID: 2)
Camera (ID: 3)
Can (ID: 4)
Template One:
Mug (Object 1):
“mug at bottom right”
Laptop (Object 2):
“laptop at top right”
Bowl (Object 3):
“bowl at top left”
Camera (Object 4):
“camera at bottom left”
Can (Object 5):
“can at center”
Template Two:
Mug (Object 1):
“bottom right mug”
Laptop (Object 2):
“top right laptop”
Bowl (Object 3):
“top left bowl”
Camera (Object 4):
“bottom left camera”
Can (Object 5):
“center can”
Template Three:
Mug (Object 1):
“mug to the right of can”
Laptop (Object 2):
“laptop to the left of mug”
Bowl (Object 3):
“bowl in front of laptop”
Camera (Object 4):
“camera behind bowl”
Can (Object 5):
“can at the top of laptop”
Template Four:
Mug (Object 1):
“1st mug from left”
Laptop (Object 2):
“2nd laptop from right”
Bowl (Object 3):
“3rd bowl from top”
Camera (Object 4):
“4th camera from bottom”
Can (Object 5):
“5th can from center”
These instructions describe the positional relationships of each object using all the four templates. They are diverse and colorful, providing various ways to describe the spatial relationships between the objects.
如果你用的是 MySQL 5.7 或更新版本，可以在每次执行一个比较大的操作后，通过执行 mysql_reset_connection 来重新初始化连接资源。这个过程不需要重连和重新做权限验证，但是会将连接恢复到刚刚创建完时的状态。
查询缓存
MySQL 拿到一个查询请求后，会先到查询缓存看看，之前是不是执行过这条语句。之前执行过的语句及其结果可能会以 key-value 对的形式，被直接缓存在内存中。key 是查询的语句，value 是查询的结果。如果你的查询能够直接在这个缓存中找到 key，那么这个 value 就会被直接返回给客户端。
有些客户端连接框架会默认连接成功后先执行一个 set autocommit=0 的命令。这就导致接下来的查询都在事务中，如果是长连接，就导致了意外的长事务。
因此，我会建议你总是使用 set autocommit=1, 通过显式语句的方式来启动事务。
但是有的开发同学会纠结“多一次交互”的问题。对于一个需要频繁使用事务的业务，第二种方式每个事务在开始时都不需要主动执行一次 “begin”，减少了语句的交互次数。如果你也有这个顾虑，我建议你使用 commit work and chain 语法。
在 autocommit 为 1 的情况下，用 begin 显式启动的事务，如果执行 commit 则提交事务。如果执行 commit work and chain，则是提交事务并自动启动下一个事务，这样也省去了再次执行 begin 语句的开销。同时带来的好处是从程序开发的角度明确地知道每个语句是否处于事务中。
空间复杂度：O(W)，其中 W 是树的最大宽度（即每层节点数的最大值）。这是因为需要使用队列来存储每层的节点。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
from collections import deque
class Node: def __init__(self, val, children): self.val = val self.children = children
def bfs(root: 'Node'): if not root: return queue = deque([root]) while queue: node = queue.popleft() # 访问当前节点 print(node.val) # 将当前节点的所有子节点加入队列中 for child in node.children: queue.append(child)
在 MySQL 中，索引是在存储引擎层实现的，所以并没有统一的索引标准，即不同存储引擎的索引的工作方式并不一样。而即使多个存储引擎支持同一种类型的索引，其底层的实现也可能不同。由于 InnoDB 存储引擎在 MySQL 数据库中使用最为广泛，所以下面我就以 InnoDB 为例，和你分析一下其中的索引模型。
所以，如果把事务 A 的查询语句 select * from t where id=1 修改一下，加上 lock in share mode 或 for update，也都可以读到版本号是 101 的数据，返回的 k 的值是 3。下面这两个 select 语句，就是分别加了读锁（S 锁，共享锁）和写锁（X 锁，排他锁）。
1 2
mysql> select k from t where id=1 lock in share mode; mysql> select k from t where id=1 for update;
再往前一步，假设事务 C 不是马上提交的，而是变成了下面的事务 C’，会怎么样呢？
事务 C’的不同是，更新后并没有马上提交，在它提交前，事务 B 的更新语句先发起了。前面说过了，虽然事务 C’还没提交，但是 (1,2) 这个版本也已经生成了，并且是当前的最新版本。那么，事务 B 的更新语句会怎么处理呢？
这时候，我们在上一篇文章中提到的“两阶段锁协议”就要上场了。事务 C’没提交，也就是说 (1,2) 这个版本上的写锁还没释放。而事务 B 是当前读，必须要读最新版本，而且必须加锁，因此就被锁住了，必须等到事务 C’释放这个锁，才能继续它的当前读。
用程序测试程序，由测试人员根据手工测试的 Case 来决定自动化测试的 Case 再编写程序或者脚本来替代手工做自动化测试。对于项目来说，手动测试和自动化测试同等重要，都是保障软件质量的方法。目前大部分的项目组都是手动测试和自动化测试相结合。因为很多测试无法做成自动化，很多复杂的业务逻辑也很难自动化，自动化测试无法取代手动测试。手工测试胜在测试业务逻辑，而自动化测试胜在测试底层架构。如果被测试的程序可测试性比较好很有必要做成自动化测试。
给你这张蓝图定一个一句话的目标，这句目标能完美的概括出这张蓝图的重点。比如 C 端 O2O 产品目标叫“围绕多、快、好、省来打造极致的用户在线交易及服务体验”；再比如 B 端 CRM 产品目标叫“建设客户全生命周期移动化、数字化管理平台”。让别人首先看到这句目标，就能快速的了解到这张蓝图的核心宗旨和愿景。
要完成蓝图内容，达到成功的样子，除了要有产品解决方案，还需要哪些业务支撑方案。即哪些业务部门需要参与哪些产品解决方案，便于更好的完成蓝图。不管是 C 端产品还是 B 端产品，要想实现蓝图内容，过程中都离不开业务部门进行支撑，比如前期一起制定业务规则、中期验收试点，后期上线推广，产品解决方案仅仅是蓝图的样子，如何将蓝图内容落地依赖业务支撑。
6、系统支撑
除了需要业务支撑，还少不了系统支撑。一个完整的 C 端 App 离开一套强大的后端系统支撑。B 端的系统同样需要相关领域的系统支撑。主要以业务场景相关的领域系统支撑为主，故障监控、数据分析等增值系统支撑为辅。
2
