<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/">
  <channel>
    <title>AI on wander</title>
    <link>https://hydarealman.github.io/wander/tags/ai/</link>
    <description>Recent content in AI on wander</description>
    <generator>Hugo</generator>
    <language>zh-cn</language>
    <lastBuildDate>Mon, 29 Jun 2026 10:28:17 +0800</lastBuildDate>
    <atom:link href="https://hydarealman.github.io/wander/tags/ai/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>AI辅助解决弹道复现BUG</title>
      <link>https://hydarealman.github.io/wander/posts/1970/01/ai%E8%BE%85%E5%8A%A9%E8%A7%A3%E5%86%B3%E5%BC%B9%E9%81%93%E5%A4%8D%E7%8E%B0bug/</link>
      <pubDate>Wed, 21 Jan 1970 23:10:23 +0800</pubDate>
      <guid>https://hydarealman.github.io/wander/posts/1970/01/ai%E8%BE%85%E5%8A%A9%E8%A7%A3%E5%86%B3%E5%BC%B9%E9%81%93%E5%A4%8D%E7%8E%B0bug/</guid>
      <description>&lt;h1 id=&#34;ai辅助解决弹道复现bug&#34;&gt;AI辅助解决弹道复现BUG&lt;/h1&gt;
&lt;p&gt;#pragma once
#include &lt;vector&gt;
// ROS相关头文件
#include &amp;ldquo;ros/ros.h&amp;rdquo;
#include &amp;ldquo;rm_msgs/Armor.h&amp;rdquo;
#include &amp;ldquo;rm_msgs/ArmorArray.h&amp;rdquo;
#include &amp;ldquo;rm_msgs/RmSerial.h&amp;rdquo;
#include &amp;lt;std_msgs/Float64.h&amp;gt;
#include &amp;lt;angles/angles.h&amp;gt;
#include &amp;lt;tf2/LinearMath/Transform.h&amp;gt;
#include &amp;lt;tf2/LinearMath/Vector3.h&amp;gt;
#include &amp;lt;tf2/LinearMath/Quaternion.h&amp;gt;
// OpenCV相关头文件
#include &amp;lt;opencv2/opencv.hpp&amp;gt;
#include &amp;lt;cv_bridge/cv_bridge.h&amp;gt;
// 标准库头文件
#include &lt;iostream&gt;
#include &lt;cmath&gt;
// 时间相关头文件
#include &lt;chrono&gt;
#include &lt;thread&gt;
#include &lt;fstream&gt;
#include &amp;lt;yaml-cpp/yaml.h&amp;gt;
// 自定义头文件
#include &amp;ldquo;Calculater.hpp&amp;rdquo;
#include &amp;ldquo;GimbalPos.hpp&amp;rdquo;
#include &amp;ldquo;TargetModel.hpp&amp;rdquo;
#include &amp;ldquo;visual.hpp&amp;rdquo;
#include &amp;ldquo;CoorConverter.hpp&amp;rdquo;
#include &amp;ldquo;math.hpp&amp;rdquo;
#include &amp;ldquo;MPC.hpp&amp;rdquo;
#include &amp;ldquo;trajectory_visualizer.hpp&amp;rdquo;
using namespace std;
using namespace cv;
/*
自瞄文档
标准模型状态向量
X(0) -&amp;gt; 机器人中心的x坐标
X(1) -&amp;gt; 机器人中心x方向速度
X(2) -&amp;gt; 机器人中心的y坐标
X(3) -&amp;gt; 机器人中心y方向速度
X(4) -&amp;gt; 左侧装甲板的固定高度
X(5) -&amp;gt; 右侧装甲板的固定高度
X(6) -&amp;gt; 小装甲板旋转半径（左侧）
X(7) -&amp;gt; 大装甲板旋转半径（右侧）
X(8) -&amp;gt; 机器人整体偏航角yaw
X(9) -&amp;gt; 偏航角速度palstance
前哨站状态向量
X(0): 机器人中心的x坐标
X(1): 机器人中心的y坐标
X(2): 第一块装甲板高度h1
X(3): 第二块装甲板高度h2
X(4): 第三块装甲板高度h3
X(5): 偏航角yaw
X(6): 偏航角速度palstance
&lt;em&gt;/
/&lt;/em&gt;*
@brief 将弧度约束在[-pi, pi]范围内，大于n，减去2n；小于-n，加上2n
@param angle 角度
&lt;em&gt;/
#ifndef _std_radian
#define &lt;em&gt;std_radian(angle) ((angle) + round((0 - (angle)) / (2 * PI)) * (2 * PI))
#endif
//追踪类
template&lt;TimeSpan _trackTime&gt;
class Tracker{
private:
double COMMAND_TIMESPAN;            //电控延迟
double local_gravity&lt;/em&gt;;              //重力加速度
double eTime;                       //曝光时间
/&lt;/em&gt; ======================== 系统参数 ======================== &lt;em&gt;/
//ROS相关
ros::NodeHandle nh;                 //ROS节点句柄
ros::Publisher debugpub;            //debug发布者
ros::Publisher debugpub1;           //debug1发布者
std_msgs::Float64 debugdate;        //debug数据
std_msgs::Float64 debugdate1;       //debug1数据
rm_msgs::RmSerial RmSerialData;     //接收串口数据
tf2_ros::Buffer tfBuffer_;            // TF 缓冲区
tf2_ros::TransformListener tfListener; // 声明一个tf2_ros::TransformListener对象，并传入tfBuffer
rm_msgs::ArmorArrayConstPtr m_armors;  // 接收装甲板数据
//图像处理相关
cv::Mat frame;          //接收的原始图像
cv::Mat frame_;         //被处理的图像副本(保护原图像)
cv::Mat camera_matrix_; //相机内参(构造函数中)
cv::Mat dist_coeffs_;   //畸变系数(构造函数中)
Image img;              //图像工具
//坐标变换工具
CAL::Calculater&lt;/em&gt; cal;   //计算工具
CoordinateTransformer* coorConverter;
//装甲板评分参数
std::vector&lt;int&gt; col;                       // 数列中的每个数代表矩阵的每一列
std::vector&lt;int&gt; row;                       // 数列中的每个数代表矩阵的每一行
std::vector&lt;int&gt; tmp_v;                     // 存储C(n,k)的中间结果
std::vector&amp;lt;std::vector&lt;int&gt;&amp;gt; result;       // 存储C(n,k)的结果
std::vector&amp;lt;std::vector&lt;int&gt;&amp;gt; nAfour;       // 存储A(n,4)的结果
std::vector&amp;lt;std::vector&lt;int&gt;&amp;gt; fourAfour;    // 存储A(4,4)的结果
std::map&amp;lt;int, int&amp;gt; row_col;                 // 存储最终结果，row_col[i]=j表示矩阵的第i行第j列是要选取的数
//数据关联参数
double min = 0, tmp = 0;
/* ======================== 跟踪控制参数 ======================== &lt;em&gt;/
//基本跟踪参数
char TrackingID;            //跟踪中的装甲板ID
bool Switch_Armor;          //装甲板切换标识符
double trackTime;           //目标丢失判定时间(秒)
//角度补偿参数
double pitch_compensation;  //pitch补偿
double yaw_compensation;    //yaw补偿
//火力控制参数
bool all_fire = false;      //完全火力模式(不停止射击)
/&lt;/em&gt; ======================== 装甲板预测参数 ======================== &lt;em&gt;/
//空间参考点参数
Eigen::Vector3d pegPos;         //空间标准点(用于装甲板跳变判断)
double peg_point_pixel_now;     //当前装甲板在像素坐标系的位置
double peg_point_pixel_last;    //位于像素标准坐标系的上一个装甲板位置
//子弹参数
double BulletVector = 22;           //子弹速度(初值给24m/s)
/&lt;/em&gt; ======================== 时间戳管理 ======================== &lt;em&gt;/
//装甲板跟踪时间
long long Now_Time_armor = chrono::time_point_cast&lt;a href=&#34;chrono::milliseconds&#34;&gt;chrono::milliseconds&lt;/a&gt;(chrono::system_clock::now()).time_since_epoch().count();//当前时间戳(用于计算丢失时间)
long long Track_Time_armor = chrono::time_point_cast&lt;a href=&#34;chrono::milliseconds&#34;&gt;chrono::milliseconds&lt;/a&gt;(chrono::system_clock::now()).time_since_epoch().count();//丢失时间戳(用于计算丢失时间)
//帧率计算
long long begin_Time = chrono::time_point_cast&lt;a href=&#34;chrono::milliseconds&#34;&gt;chrono::milliseconds&lt;/a&gt;(chrono::system_clock::now()).time_since_epoch().count();//首时间
long long end_Time = chrono::time_point_cast&lt;a href=&#34;chrono::milliseconds&#34;&gt;chrono::milliseconds&lt;/a&gt;(chrono::system_clock::now()).time_since_epoch().count();//尾时间
// C++工具时间戳
long long tool_begin_Time = chrono::time_point_cast&lt;a href=&#34;chrono::milliseconds&#34;&gt;chrono::milliseconds&lt;/a&gt;(chrono::system_clock::now()).time_since_epoch().count();//首时间
long long tool_end_Time = chrono::time_point_cast&lt;a href=&#34;chrono::milliseconds&#34;&gt;chrono::milliseconds&lt;/a&gt;(chrono::system_clock::now()).time_since_epoch().count();//尾时间
// ros工具时间戳
ros::Time tool_begin_Time_ros = ros::Time::now();
ros::Time tool_end_Time_ros = ros::Time::now();
// 获取装甲板tf时间(判断是否是相同帧)
ros::Time last_tf_time = ros::Time::now();
/&lt;/em&gt; ======================== 标志位 ======================== &lt;em&gt;/
bool functional = true;                 // 射击模式
int m_center_tracked;                   // 锁中心状态标志位
bool m_track_center;                    // 是否跟随中心
bool m_fix_on;                          // 重力补偿开关
std::string config_path_;               // 存储配置路径
unique_ptr&lt;TargetModel&gt; targetModel;    // 目标模型
ros::Publisher AngPub;                  // 角度话题发布者
std::shared_ptr&lt;MPC&gt; m_MPC;             // 模型预测控制器
// =========================== 阈值 ====================================
double m_score_tolerance;               //装甲板匹配得分最大值
double m_switch_threshold;              // 更新装甲板切换的角度阈值，角度制
double m_force_aim_palstance_threshold; // 强制允许发射的目标旋转速度最大值，弧度制
double m_aim_angle_tolerance;           // 自动击发时目标装甲板相对偏角最大值，角度制
double m_aim_pose_tolerance;            // 自动击发位姿偏差最大值，弧度制
double m_aim_center_angle_tolerance;    // 跟随圆心自动击发目标偏角判断，角度制
double m_switch_trackmode_threshold;    // 更换锁中心模式角速度阈值，弧度制
double m_aim_center_palstance_threshold;// 跟随圆心转跟随装甲板的目标旋转速度最大值，弧度制
// =========================== 可视化 ===================================
std::vector&amp;lt;std::vector&lt;a href=&#34;Eigen::Vector3d&#34;&gt;Eigen::Vector3d&lt;/a&gt;&amp;gt; visual_armor_position_pose_temp;  // 用于可视化存储观测装甲板的全局变量
GimbalPose m_cur_pose;                  // 当前位姿
GimbalPose m_target_pose;               // 目标位姿
GimbalPose m_target_pose_debug;         // 用于debug,比较mpc和传统模式
// =========================== 串口补偿 =======================================
double m_rollOffset = 0;
double m_pitchOffset = 0;
double m_yawOffset = 0;
public:
Tracker(ros::NodeHandle&amp;amp; nh,const std::string&amp;amp; config_path) : config_path_(config_path), tfListener(tfBuffer_)
{
this-&amp;gt;nh = nh;
AngPub = nh.advertise&amp;lt;geometry_msgs::Vector3&amp;gt;(&amp;quot;/auto_angle&amp;quot;, 1000);
debugpub = nh.advertise&amp;lt;std_msgs::Float64&amp;gt;(&amp;quot;/debugpub&amp;quot;, 1000);
debugpub1 = nh.advertise&amp;lt;std_msgs::Float64&amp;gt;(&amp;quot;/debugpub1&amp;quot;, 1000);
cal = new CAL::Calculater(this-&amp;gt;nh,this-&amp;gt;img);
tfBuffer_.setUsingDedicatedThread(true);
m_armors.reset(); // 显式初始化为空
// 初始化时创建 TargetModel
targetModel = std::make_unique&lt;TargetModel&gt;(config_path_);
coorConverter = new CoordinateTransformer(config_path_);
m_MPC = std::make_shared&lt;MPC&gt;(config_path_); // 控制器初始化
// 检查配置文件路径是否有效
if (!config_path_.empty()) {
try {
setParam(config_path_);
ROS_INFO(&amp;ldquo;Successfully loaded parameters from: %s&amp;rdquo;, config_path_.c_str());
} catch (const std::exception&amp;amp; e) {
ROS_ERROR(&amp;ldquo;Failed to load parameters: %s&amp;rdquo;, e.what());
}
} else {
ROS_WARN(&amp;ldquo;No configuration file path provided. Using default parameters.&amp;rdquo;);
}
}
~Tracker() {
delete cal;
delete coorConverter;
}
/&lt;/em&gt;***************
* @brief 回调函数: 接受串口信息，并更新内部变量、TF、坐标系
* @param &lt;em&gt;serial ROS 消息的智能指针，包含子弹速度、射击标志、补偿角度等
&lt;em&gt;/
void SetSerial(const rm_msgs::RmSerialConstPtr _serial){
if (_serial) {
RmSerialData = &lt;em&gt;_serial;
// 目前注释掉了(到时候测试一下)
// if(_serial-&amp;gt;BulletVec &amp;gt; 10){
//     BulletVector = _serial-&amp;gt;BulletVec;
// }
if(_serial-&amp;gt;ShootFlag == &amp;lsquo;f&amp;rsquo;){
functional = true;
}else if(_serial-&amp;gt;ShootFlag == &amp;lsquo;a&amp;rsquo;){
functional = true;
}else{
functional = true;
}
// 从串口获取当前装甲板的姿态
m_cur_pose.roll = RmSerialData.Roll;
m_cur_pose.pitch = RmSerialData.Pitch;
m_cur_pose.yaw = RmSerialData.Yaw; &lt;br&gt;
// debug
// ROS_INFO(&amp;ldquo;cur: pitch:  %lf&amp;rdquo; , RmSerialData.Pitch);
// ROS_INFO(&amp;ldquo;BulletVector:  %lf&amp;rdquo; , BulletVector);
// std::vector&lt;a href=&#34;Eigen::Vector3d&#34;&gt;Eigen::Vector3d&lt;/a&gt; imuabsPos = cal-&amp;gt;GetPos(&amp;ldquo;map&amp;rdquo;,&amp;ldquo;imu&amp;rdquo;,1);
// cal-&amp;gt;TFUpdata(&amp;ldquo;map&amp;rdquo;,&amp;ldquo;imuabs&amp;rdquo;,{0.0, 0.0, 0.0},{0.0, 0.0, imuabsPos[1].z()},0);
// ROS_WARN(&amp;ldquo;have serial 3333333333333333333333333333&amp;rdquo;);
}
}
/&lt;/em&gt;&lt;/em&gt;***************
* @brief 回调函数: 接收相机节点发送的图像,用于debug
* @param img&lt;/em&gt; 图像信息
* @param frame  供算法线程直接使用的原始图
* @param frame_ 额外再 clone 一份，用于可视化
&lt;em&gt;/
void doimage(const sensor_msgs::ImageConstPtr img_)
{
cv_bridge::CvImagePtr cv_ptr;
try
{
cv_ptr =  cv_bridge::toCvCopy(img_, sensor_msgs::image_encodings::BGR8);
}
catch(cv_bridge::Exception&amp;amp; e)
{
ROS_ERROR(&amp;ldquo;cv_bridge exception: %s&amp;rdquo;, e.what());
return;
}
frame = cv_ptr-&amp;gt;image.clone();
frame_ = frame.clone();
// ROS_WARN(&amp;ldquo;have image 111111111111111111&amp;rdquo;);
}
// 回调函数: 接收识别发送的装甲板序列
void doArmors(rm_msgs::ArmorArrayConstPtr armors)
{
m_armors = armors;
// ROS_WARN(&amp;ldquo;have armor 222222222222222222&amp;rdquo;);
}
/&lt;/em&gt;*
* @brief  主跟踪循环：每帧调用一次，完成“决策 → 预测 → 补偿 → 发布”全链路
&lt;em&gt;/
void Track()
{
if (!m_armors) {
cout &amp;laquo; &amp;ldquo;消息队列为空&amp;rdquo; &amp;laquo; endl;
return;
}
try
{
//begin_Time = chrono::time_point_cast&lt;a href=&#34;chrono::milliseconds&#34;&gt;chrono::milliseconds&lt;/a&gt;(chrono::system_clock::now()).time_since_epoch().count();
if(!functional){
return;
}
TargetModel&lt;/em&gt; targetModel_temp = nullptr;
targetModel_temp = armorUpdate(m_armors);
if(targetModel_temp != nullptr){
cv::Point2d finAngle = {0.0, 0.0};
GimbalPose target_pose_temp = reconstruction_choose_compensation();
// 调试输出(打印云台需要转动到的角度)
// cout &amp;laquo; &amp;ldquo;pitch: &amp;quot; &amp;laquo; target_pose_temp.pitch &amp;laquo; &amp;quot; &amp;quot; &amp;laquo; &amp;ldquo;yaw: &amp;quot; &amp;laquo; target_pose_temp.yaw &amp;laquo; endl;
// 打印需要移动的相对角
// finAngle.x = target_pose_temp.pitch - m_cur_pose.pitch; // 计算需要移动的pitch角度
// finAngle.y = target_pose_temp.yaw - m_cur_pose.yaw;     // 计算需要移动的yaw角度
// // // 陀螺仪的绝对角
finAngle.x = target_pose_temp.pitch; // 计算需要移动到的pitch角度
finAngle.y = target_pose_temp.yaw;     // 计算需要移动到的yaw角度
// debug: 云台跟随效果rqt_plot打印
// yaw角
// debugdate.data = m_cur_pose.yaw;            // 当前云台yaw角度
// debugdate1.data = target_pose_temp.yaw;     // 计算出云台需要转动的yaw角度
// // pitch角
// debugdate.data = m_cur_pose.pitch;          // 当前云台pitch角度
// debugdate1.data = target_pose_temp.pitch;   // 计算出云台需要转动的pitch角度
// debug: 自动打弹打印
// cout &amp;laquo; &amp;ldquo;finAngle.x: &amp;quot; &amp;laquo; finAngle.x &amp;laquo; &amp;quot; &amp;quot; &amp;laquo; &amp;ldquo;finAngle.y: &amp;quot; &amp;laquo; finAngle.y &amp;laquo; endl;
// cout &amp;laquo; &amp;ldquo;是否允许打弹: &amp;quot; &amp;laquo; targetModel_temp-&amp;gt;auto_fire &amp;laquo; endl;
// if (targetModel_temp-&amp;gt;auto_fire) {
//     debugdate.data = 1;
// }
// else {
//     debugdate.data = 0;
// }
Pub_Aangle(true, targetModel_temp-&amp;gt;auto_fire, finAngle);
}else{
Pub_Aangle(false);
}
// 帧率控制
// double time_line = 30.0;
// end_Time = chrono::time_point_cast&lt;a href=&#34;chrono::milliseconds&#34;&gt;chrono::milliseconds&lt;/a&gt;(chrono::system_clock::now()).time_since_epoch().count();
// double frame_time = (end_Time - begin_Time)/1000.0;
// if ((end_Time - begin_Time) - time_line &amp;lt; 0.0)// 帧率控制
// {
//     int sleep_time_ms = static_cast&lt;int&gt;(time_line - (end_Time - begin_Time));
//     std::this_thread::sleep_for(std::chrono::milliseconds(sleep_time_ms));
//     //frame_time = 0.03;
//     end_Time = chrono::time_point_cast&lt;a href=&#34;chrono::milliseconds&#34;&gt;chrono::milliseconds&lt;/a&gt;(chrono::system_clock::now()).time_since_epoch().count();
//     frame_time = (end_Time - begin_Time)/1000.0;
//     // cout &amp;laquo; &amp;ldquo;sleep_time_ms:&amp;rdquo; &amp;laquo; sleep_time_ms &amp;laquo; &amp;ldquo;ms&amp;rdquo; &amp;laquo; endl;
//     // cout &amp;laquo; &amp;ldquo;frame_time:&amp;rdquo; &amp;laquo; frame_time
1000 &amp;laquo; &amp;ldquo;ms&amp;rdquo; &amp;laquo; endl;
// }
// begin_Time = end_Time;
// debugdate1.data = frame_time
1000;
debugpub.publish(debugdate);
debugpub1.publish(debugdate1);
}
catch (const std::exception&amp;amp; e)
{
ROS_ERROR(&amp;quot;[Exception] In Track function: %s&amp;rdquo;, e.what());
}
}
// 重构选板
GimbalPose reconstruction_choose_compensation() {
// 目标装甲板
Armor abs_facing_armor;
Armor abs_target_armor;
double hit_time = 0;
double center_hit_time = 0;
double m_time_off = COMMAND_TIMESPAN + eTime + 0.025;
/**
* 严格意义上来说，如果要准确预测击中时刻的装甲板位置的话，需要解一个非线性方程。此处采用一种近似的解法
* 根据当前最近装甲板距离计算击中时间，用于预测目标装甲板出现的位置
* 事实上相当于一步牛顿迭代法，或者说一阶的线性化&lt;/p&gt;</description>
    </item>
    <item>
      <title>ai使用指南</title>
      <link>https://hydarealman.github.io/wander/posts/1970/01/ai%E4%BD%BF%E7%94%A8%E6%8C%87%E5%8D%97/</link>
      <pubDate>Wed, 21 Jan 1970 23:10:23 +0800</pubDate>
      <guid>https://hydarealman.github.io/wander/posts/1970/01/ai%E4%BD%BF%E7%94%A8%E6%8C%87%E5%8D%97/</guid>
      <description>&lt;h1 id=&#34;ai使用指南&#34;&gt;ai使用指南&lt;/h1&gt;
&lt;p&gt;Deepseek&lt;/p&gt;
&lt;h2 id=&#34;一推理模型与指令模型&#34;&gt;一，推理模型与指令模型&lt;/h2&gt;
&lt;p&gt;指令模型v1,豆包&amp;hellip;
你需要使用结构化的指令
推理模型o1,r1&amp;hellip;.
你只需要清晰明确的表达你的需求&lt;/p&gt;
&lt;h2 id=&#34;二理解大语言模型的本质&#34;&gt;二，理解大语言模型的本质&lt;/h2&gt;
&lt;p&gt;特点1：大模型在训练时是将内容token化的，大模型看到和理解的世界与你不一样
特点2：大模型知识是存在截止时间的
r1的截止时间大概在2023年的10月到12月
问题：
行业认知断代问题
解决方法：打开联网搜索，或者上传文档
特点3：大模型缺乏自我认知/自我意识
多数模型都不知道自己是什么模型，除非在部署的时候在系统提示词做了对应设定
特点4：
大模型有记忆限制（64k/128k）
中文字大概最多3到4万字
对话轮数过多，可能会遗忘最初的聊天问题
特点5：
输出长度有限2000-4000&lt;/p&gt;</description>
    </item>
    <item>
      <title>OpenVINO</title>
      <link>https://hydarealman.github.io/wander/posts/1970/01/openvino/</link>
      <pubDate>Wed, 21 Jan 1970 23:10:23 +0800</pubDate>
      <guid>https://hydarealman.github.io/wander/posts/1970/01/openvino/</guid>
      <description>&lt;h1 id=&#34;openvino&#34;&gt;OpenVINO&lt;/h1&gt;
&lt;p&gt;OpenVINO 是做什么的？
OpenVINO 是英特尔（Intel）开源的一套工具包，专门用于加速 AI 模型的推理（Inference）。
它的核心职责： 它不负责训练模型（那是 PyTorch 或 TensorFlow 的工作），它只负责使用模型。它能把你训练好的模型进行底层指令集的优化，让它在 Intel 的硬件（比如 CPU、集成显卡 iGPU、或者最新的 NPU）上跑得飞快。
为什么用 C++： 虽然 Python 开发快，但在工业落地（如自动驾驶、安防监控、医疗设备）中，通常要求极低的延迟和极高的性能，这时候 C++ + OpenVINO 就是黄金搭档。&lt;/p&gt;</description>
    </item>
    <item>
      <title>Prompt Engineering 提示工程</title>
      <link>https://hydarealman.github.io/wander/posts/1970/01/prompt-engineering-%E6%8F%90%E7%A4%BA%E5%B7%A5%E7%A8%8B/</link>
      <pubDate>Wed, 21 Jan 1970 23:10:23 +0800</pubDate>
      <guid>https://hydarealman.github.io/wander/posts/1970/01/prompt-engineering-%E6%8F%90%E7%A4%BA%E5%B7%A5%E7%A8%8B/</guid>
      <description>&lt;h1 id=&#34;prompt-engineering-提示工程&#34;&gt;Prompt Engineering 提示工程&lt;/h1&gt;
&lt;h1 id=&#34;1什么是提示词工程&#34;&gt;1.什么是提示词工程&lt;/h1&gt;
&lt;p&gt;当前是AGI时代
AGI Artificial General Intelligence 通用人工智能&lt;/p&gt;
&lt;h2 id=&#34;我们在提示工程上的优势&#34;&gt;我们在提示工程上的优势&lt;/h2&gt;
&lt;p&gt;我们懂原理,所以知道
为什么有的指令有效,有的指令无效
为什么同样的指令有时有效,有时无效
怎么提升指令的有效的概率&lt;/p&gt;</description>
    </item>
  </channel>
</rss>
