2024 08 05, 2003 今日內容

2024-08-05, 20:03-今日內容

vim /vs code快捷键： 方法method和函数 function的区别。 class里面的函数和外面的函数，不是一样的调用方式哦 Class 的定义 Print 的输出 f string Python里面的提示类型： Jupyter notebook vs code快捷键 把某行代码随意移动 只用键盘 initialize的是给每一个embedding的table的每一个空格赋值。 但是forward。是利用我们已经创建好的table… Constructor的继承。 也就是__init__ 的继承， super（）.init()的写法 sparse vector 和dense vector 离散的索引和连续的vector Embedding 创建的是vocab size 的row 和vocab size的column 关于def init(self, … ) 关于调用别人写好的函数，怎么指定参数： Super（）的用法，还有class的继承 nn里面都包含什么东西（torch） nn.Module 是啥意思（pytorch） Positional encoding 可能会用到的概率相关的东西 （ML/NN） New Note 输：one hot y=x 右偏数据，数据在左侧集中，向右逐渐减少，符合指数分布的特性 propobility 在ML中必须掌握的点。 Zip的作用 slicing 冒号： Min(), max () sum()等等是接受iterable的对象的，所以当我们用len(i) for I in …这种generator… Str.splitlines()可以把输入的str的空格消掉，也就是将str搞成只有word的一个新的list Negatively log likelihood loss 就是cross entropy loss Batch size 是啥意思 一句话的序列，怎么一个一个往后推来做训练数据 training的时候 要保证是random samplized tokenizor validation的重要性 Lambda 的用法 （匿名函数） 字典dictionary的创建 Enumerate 返回的值是可以iterate的，也就是可以用for来处理他的返回value。所以for i, j in enumerate… iPad可以看网页学习，连商场的wifi。mac连自己的热点，ipad在左边，充电线插在右边。iPhone在左边，充电线在左边。… decoding encoding 字符来做chatgpt， 做成字典的样子（正反字典），用enumerate set{}转换成list 切片操作 也就是： 不只有在numpy array时可以用的，python的字符串r和list都可以用 ASCII和utf-8 的区别 Open（文件位置，mode=‘r/w/x’/a, encoding=‘utf-8’) as f: with （python里面的意思） subprocess Wget的用法，主要是从www上面拿一些数据，比如txt或者csv seed Torch argmax的例子： PDF 是概率密度函数 Z就是我们说的logits Dense layer 全连接层 -（针对分类问题的，也就是categorical） batch normalization layer Tensorflow keras的关系 fork别人的repo，在GitHub RNN LSTM 对于轨迹的预测 matrix multiplication和dot product的关系 Dot product 点积 Eigenvectors and Eigenvalues inverse matrix逆矩阵 Equation 等式转换成matrix的方法 Cross entropy loss function 交叉熵损失函数和softmax 的组合 来确定预测出的标签和实际标签的概率… 常用函数和他的导数 常用函数和他的导数 neuron和weight 之间的点亮方式 Sigmoid function 把-无穷大到正无穷转化到0-1区间 的squishification function neuron是什么 weight 和bias Back propagation 的calculus 微积分的运算逻辑 + 为什么不能直接求导为0-》解决思路是gradient… Integral 积分f （calculus 微积分） uniform distribution 和 normal distribution np.random.rand()的用法 Help的用法 Assert 检查是否位true，如果不是 会反回错误消息 Buffer 是什么意思（缓冲区） Linux command line 的命令 Linux 本地访问Kaggle 数据 Multivariable function多变量函数 , partial derivative偏导数, gradients梯度 导数 derivative 1500 mile ‎ = 2,414.016 kilometers MNIST NN digits detection from scratch One hot encoding 对于 MNIST DATSET的实现。 主要是对Y label的coding 把它转化成matrix… 向量的维度混淆

2024-07-27-我想知道为什么你可以把m写在h的前面，难道维度m不是每个数据的第二维度的标志吗？你把它写在第一位是什么意思…

NN的权重矩阵，shape，bias的shape R 的n次方表示的是实向量空间（real vector space） Linear Algebra: linear combination of two vectors Linear Algebra：Vector 的变换 如果非要熬夜，三个小时是最划算的睡眠时间， 可以完全恢复，下次熬夜可以试试，要不然就是4.5，或者6，或者7.5个小时。 每次间隔… iPad用来打开chatgpt和google translate

2024-07-26-点乘和matrix 乘以matrix 有什么不一样吗？ 什么时候该用什么点乘，什么时候该用matrix乘法…

Vector 和scaler Matrix equations in NN Transformer Neural Network（attention mechanisim）

2024-07-25-为什么weight不够描述，还要加入bias。 感觉back propogation的过程，偏导数很复杂…

激活函数的作用（NN里面）

2024-07-25-NN里面说的每个neuron的activation是怎么回事呢？ activation减去y是cost？ 为什么…

2024-07-25-chain rule在NN的作用， back propagation跟chain rule有什么关系

Chain rule 在NN的作用 backpropogation 和forward propogation gradient descent 是什么 What is RNN? NN 的结构， weights 和biases的解释 Sigmoid & Relu in NN Context vector in Encoder and Decoder

2024-07-25-encoder decoder LSTM是supervised 还是unsupervised ，你知道训练…

Long short term memory = cell + hidden states

2024-07-25-embedding的维度 你是怎么确定的 呢？ 刚刚你说维度是 4 ，是随便乱说的吗？ 刚刚3个word…

LSTM的各种state和gate Sigmoid 和tanh 的区别 Sigmoid activation

2024-07-24-我不理解为什么需要遗忘长时间记忆，LSTM 你刚刚说的 你能解释吗

2024-07-24-LSTM 到底是会忘记长期还是短期记忆？

2024-07-23-如果我的mac 对我的blog进行了推送到GitHub 更新了。我的raspberry pi上是不是不能…

2024-07-23-embedding

2024-07-23-tanh的作用和图像

Tanh， 把任意输入的从-inifi 到+infinit的value压缩到-1 和+1 之间

2024-07-23-anh 函数在LSTM里面有什么作用吗？ 他和new hidden state, previous hidden…

2024-07-23-环神经网络（RNN）在处理长序列数据时，存在“短期记忆”的问题，即它们在长时间步之后难以保留早期的信息。这…

2024-07-23-请解释为什么new weights = weight - learning rate * gradient…

2024-07-23-fully connected layer 为什么是another name of a basic vanilla…

2024-07-23-encoder和decoder的时候，要提到LSTM

encoder和decoder的时候，要提到LSTM

2024-07-23-embedding和encoding解惑

Embedding为每个词创建了2个嵌入值（即向量的维度是2）

2024-07-23-browser的设置问题

2024-07-22-tensorflow 和pytorch 我该选哪一个。

tokenizer就是分词器

2024-07-22-embedding 和encoding 的区别

2024-07-22-FFNN feedforwardneuralnetworks transformer languagemodel…

2024-07-19-最快掌握lstm和attention的学习路线

2024-07-18-新单词

2024-07-18-vscode GitHub 账号登不上，或者push不了的问题

2024-04-19-路径跟踪”（path tracking）

2024-02-21-gymnasium在jupyter notebook 里render播放动画

2024-02-16-为啥0就是删除了这个维度啊？？

2024-02-12-axis=0（行方向）进行操作时，想象你是在垂直方向添加或修改这个表格。 为什么你默认一开始就是垂直的来…

2024-02-11-vmap 是 JAX 中的一个函数，用于自动将普通函数向量化，以便在数组的批处理维度上并行执行。

2024-02-11-as_action方法则提供了将轨迹更新转换为动作的便利途径，使得不同的动力学模型能够在统一的框架下交互…

2024-02-11-dynamics_model = dynamics.StateDynamics() 为什么我要用state…

2024-02-10-怎么从log_trajt和sim_traj(t+1),推断t的action

2024-02-10-sim——trajectory为什么和logged traj不是同一个。需要两个同时存在吗？

2024-02-10-IDMRoutePolicy类继承自WaypointFollowingPolicy，这意味着它是一种特定…

2024-02-08-为什么明明modeled vehicle的轨迹会出现-1， -1呢。莫名其妙

2024-02-07-我在Jupyter notebook上 怎麼看一個class所擁有的所有屬性或者method

2024-02-06-為什麼title要寫在head裡面？ 而不是寫在html裡

2024-02-06-html和java css python 的關係？

2024-01-27-dd

2024-01-27-ee

2024-01-27-ss

haha

2024-01-27-ceshi

2024-01-27-為什麼要在每一層的code是這樣聯結的呢？ LSTM , attention DENSE

2023-10-28-利用lstm model 更新policy 裡面的speed

2023-10-27-為什麼shape縮小了呢，原來不是三個維度嗎，現在怎麼變2維度了

2023-10-27-jnp.stack([x, y, vx, vy, yaw, acc, valid, length, width…

2023-10-27-用于指示场景中与对象张量的第一维度相对应的哪些对象具有交互式行为。最多可以选择2个对象。此列表中的对象形成…

2023-10-26-分析waymaxactor和expert的model的流程

2023-10-26-沒懂Hashable 啥意思。 還是有aux data

2023-10-26-道路的點數據（道路/紅綠燈等）怎麼利用

2023-10-26-waymo dataset 數據類型

New Note

2023-10-21-waymax install

2023-10-22-类型注解是什麼

2023-10-22-你說的src test都有init .py 他是用來幹什麼的

2023-10-22-# 使用 for 循环迭代 simulator1 对象

2023-10-22-iter __next__這種寫法，在python上是不是約定俗成的，如果要讓一個class變的…

2023-10-22-為什麼simple decorator 的參數fn, 並沒有被當作參數船東給wrapped. , wrapped…

2023-10-20-windows登陸linux ， xrdp

3 min - proposal updated 可以提交了。

2023-10-19-我如果把模型替換成lstm預測的模型，或者考慮加速度。這樣對比的研究。

2023-10-19-辆速度和加速度分析:

2023-10-19-我獲取到了在紅綠燈控制的交叉路口，所有車輛，包括車輛類型的軌跡，我能做什麼呢？

現在用car+brake訓練的模型不錯。 繼續吧vehicle type加進去class訓練

2023-10-18-怎麼把兩個模型對同一個image的的檢測的txt合併。一個在label s文件夾，一個在labels_new…

2023-10-18-利用模型yolovx.pt檢測車輛類型，最後保存到標籤txt格式。

明天重新吧train dataset的images（特別是traffic light）那一塊的 重新標記（因為只標記了紅綠燈，導致…

2023-10-18-比較好的數據庫 taillight 韓國國民大學

2023-10-18-是的，根据代码中的逻辑，只有当车辆经过这些预定义的多边形区域时，它们才会被识别和计数。这些区域是通过 ZONE_IN_POLYGONS…

2023-10-18-區域counting vehicle

2023-10-18-本地查看模型訓練的進度tensorboard

2023-10-18-我的訓練設置

Hello Professor. Thank you for taking the time to meet with me. I…

2023-10-17-TRB評審意見

2023-10-17-我拿到了車輛運動軌跡的pattern .然後訓練一個模型用它來識別交通衝突。可行嗎？ 那我的benchmark…

2023-10-17-traffic light detection dataset

2023-10-17-tqdm

2023-10-17-multiple gpu handling

avoid text book lecturing

2023-10-15-trackingcouting code

2023-10-15-是我兩個yolov8的模型，他們的class如上。 我能把這兩個模型融合成一個，然後讓那個模型能夠檢測所有…

2023-10-15-drone tracking and counting

2023-10-15-安裝cython-bbox

2023-10-15-本地部署cythonbox tracker

2023-10-15-好了，教我怎麼給我的video做這個lstm的訓練吧。我只有視頻數據，記住。我也沒有任何的標籤

2023-10-15-如果在未来5秒内，煞车灯的频率超过了某个阈值（表示连续煞车）并且跟车距离低于另一个阈值，那么标签为“危险…

2023-10-15-3. 数据标注

2023-10-15-滑动窗口技术：基于连续的帧，使用滑动窗口提取时间序列特征。 這一個技術具體點，比如說我要提取10秒這個時…

2023-10-15-特征工程：

2023-10-15-驾驶行为模式：

2023-10-15-驾驶行为模式：

2023-10-15-brake distance light

2023-10-15-車輛煞車燈亮起這個數據 可以怎麼分析

2023-10-14-ustoopia/Live-stream-server-portable-Windows-Nginx-RTMP…

2023-10-10-body 和struct 是不是都屬於view的一個subclass？

2023-10-10-@State private var isButtonEnabled = true 是不是意味著 有了…

2023-10-10-swift

2023-10-10-virtualenv pi

2023-10-10-public class HuskIdleState : HuskGroundState 這句話是不是可以…

2023-10-10-值得學習的github

2023-10-08-為什麼我的enemy進入不了idle state

2023-10-07-你讲讲 unity 的animator里面，有个trigger的类型。 什么时候该用trigger，什么…

2023-10-06-那我的敵人的的代碼。在folder裡面應該怎麼組織呢？ 是抖創建一個folder是你說的總的enemy的…

2023-10-06-我這個代碼，怎麼當我退出這個狀態的時候，player的位置沒有在原來我存儲的位置啊

2023-10-04-hollo knight wiki

2023-10-02-自动驾驶rpg游戏

2023-10-01-currentDashes–; 為什麼要用減法 而不是檢查加法？

2023-09-30-為什麼dash state 要繼承player state 而不是airs state or jump-state…

2023-09-30-再講講為什麼要一個timer 來稿dash ,而不是直接給dash 設置一個時間，然後讓人物直接在時間短…

2023-09-30- if (moveDirection < 0 && transform.localScale.x > 0…

2023-09-30-float moveDirection = Input.GetAxis(“Horizontal”); 為什麼…

2023-09-30-為什麼在components裡的physics2的没有overlap circle 这个选项？ 代码里却…

2023-09-30-什么时候需要添加rigid body？ 还有collider

2023-09-30-if (isGrounded()) 為什麼isgrounded要加括號，

2023-09-30-transform和vector2區別

2023-09-30-我这些代码应该放哪个class？ player吗，还是player state？还是grounds state…

2023-09-29- 为什么jump button按下去这个代码要放在ground state这个class，而不是jumps…

2023-09-29-superstate的继承与管理

2023-09-29-private protected public

2023-09-29-xbox手柄检测unity以及键位

2023-09-29-Platform是否需要加collider和rigidbody

2023-09-29-game里人物的运动

2023-09-29-class和屬性的區別

2023 study permit 我跟这个世界的连接又少了一点 Brady listing 119 table finish 數據同步 In our modern transportation ecosystem, ensuring road safety and optimizing…

1. Thesis Objectives: I have drafted a comprehensive table outlining… 车牌 清晰一点 余额交易必须满足绑定手机令牌满15天，且开通社区市场功能。邮箱验证不行！ nickname for social club: Luckysouth 电脑更新： 妈肚子又开刀了 zhouxingnan2016@gmail.com

   2023-09-06-我的CSQ申請

   2023-09-06-CSQ Spousal sponsership 申請

   2023-09-06-PR 申請術語

   2023-09-06-PR填寫表格

   2023-09-06-PR擔保材料

   2023-09-06-tfliteyolov4檢測視頻，只檢測第一幀的修改

   今天丫丫不见了

   2023-08-30-Raspberry pi VPN setup 静态ip

   2023-09-03-安卓刷機教程 Google pixel6a

   2023-08-31-ipad玩LOL

   2023-08-31-windows家庭版打开远程控制

   2023-08-31-要干的事

   2023-08-31-PI上创建samba共享文件夹（创建文件服务器server）

   2023-08-30-Router 登陆

   2023-08-29-chatgpt说福原爱是柯文哲老婆

   2023-08-29-chatgpt说福原爱老公是柯文哲

   2023-08-28-Tt

   11:24 PM Mon Aug 28

   2023-08-28–rf

   2023-08-28-raspberrypi 使用靜態IP（Wi-Fi的連結）

   2023-08-28-調用棧callstack

   2023-08-28-vscode 波浪線

   2023-08-24-Google maps api 怎麼通過gps定位信息獲取那個路段的車道信息

   2023-08-24-把GPS的信息和道路上的車道標誌標線一起顯示

   2023-08-24-folium建立GPS的可視位置

   2023-08-24-小數度 = 度 + (分 / 60) + (秒 / 3600) 為什麼度跟分分秒有關係？

   2023-08-24-45 deg 30’ 14.00” N 45.5038888888889, -73.6694027777778…

   2023-08-24-为什么人长大了后就文艺不起来了

   2023-08-24-从手机上写博客推送github

   2023-08-24-测试博客

   2023-08-24

   2023-08-24

   2023-08-24 - 测试

   2023-08-24 测试博客

   2023-08-24, 05:19 我要写博客1

   iPad写GitHub博客并推送，结合blinkshell

   raspberrypi login

   pandoc template

   MacTex BasicTeX

   latex

   conda remove package

   conda remove package

   test

   conda remove package

   pip uninstall package

   pandoc

   bash

   ssh

   shebang

   conda create environment python=xxx

   conda delete env

   how to get splitter text one by one

   notes的寫法

   車道檢測 opencv

   markdown基本用法

   Markdown編輯器

   Opencv 包的組成

   bear和notes的工作屆流程

   Opencv顏色的轉換

   車道檢測的code

   Gps數據exif的tag處理

   Opencv主要結構和組成部分

   Markdown 用法

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

vim /vs code快捷键： 删除 DD 是要esc 到cell。然后按两下DD 才是删除。

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

方法method和函数 function的区别。 class里面的函数和外面的函数，不是一样的调用方式哦 方法是class的函数要想用某个class里面的方法，我们就必须要有某个class的instance。 也就是创建一个真实的。 函数就是函数，放在别的任何地方的，他是独立的！

他们两在调用的时候有非常大的不同！ Class里面的method在调用的时候，使用一个小点。 Function在调用的时候，就是用（）来调用。 这里有个例子：

class Example: def method(self): print(“This is a method”)

创建类的实例

example_instance = Example()

调用方法

example_instance.method() # 输出: This is a method

def backward(): print(“This is a function”)

调用函数

backward() # 输出: This is a function

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Class 的定义 如果要定义class 不要写错了，他不是函数，不需要一开始就在class 啥啥啥的时候写他的函数。 Class的输入的定义要统一的放在__init__里面，这样才是对的额/。 每定义一个class的函数，都要有self写进去。 就像是这样： class jynxzzzLoss: def init(self, value): self.value = value

def backward(self):
    print(f'backward called with value: {self.value}')

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Print 的输出 f string 写法就是f’ 在里面要是要调用variable的话，就加上{}就好了’

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Python里面的提示类型： ⁃ 字典是这样的：

Dict[str, Any] 表示key是str类型的，value是任意类型的

⁃	可以迭代的是这样的： Iterable[]

多种类型的并集是这样的： Union[int, str] 代表可以是int 也可以是str

Any是表示咋都行。

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Jupyter notebook 只运行当前的，别移动到下一个 Control + enter

我自己经常用的 shift + enter

debug ： 1. 设置红点 2. control + shift enter 3. 出现debug得console

一行一行的执行： F10

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

vs code快捷键 shift + comman + p （更改设置的panel）

shit + command + m （下面的warning）

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

把某行代码随意移动 只用键盘 只需要记住是Alt

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

initialize的是给每一个embedding的table的每一个空格赋值。 但是forward。是利用我们已经创建好的table… initialize的是给每一个embedding的table的每一个空格赋值。 但是forward。是利用我们已经创建好的table来lookup value。 所以才会出现我问的这个问题。 def forward(self, idx): return self.embedding(idx) 这里的embedding(idx)为什么只需要输入一个参数，我看到nn.Embedding不是需要两个参数的吗？ self.embedding是跟nn.embedding是完全一样的函数啊

在这里self.embedding(idx)其实是在调用函数了。 你要搞清楚现在我们的模型已经经过了初始化，所以他已经有了这个embedding 的table。 现在我们只是从这个table里抽取我们需要的word的value，所以现在这个表达式其实是用index来对一个nn.torch.tensor进行抽取row的操作。

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Constructor的继承。 也就是__init__ 的继承， super（）.init()的写法 其实在python3中，只要写成最简单的形式就好了。 不需要写class的名字了。 这里的class名字就是自己最新定义的class的名字。self就是现在的实例对象。

 super(BigramLanguageModel, self).init()，但在 Python 3 中，可以简化为 super().init()。

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

sparse vector 和dense vector Dense vector： 我们创建的np的vector或者torch的vector，一般都是显式的，是dense的vector。他们一般都非常有利于计算，因为他们都显式存储在内存中的， 包括0

Sparse vector： 不是显示的存储在内存的，一般我们都不会碰。 他就是only 存储非零的element，和他的索引。 所以计算效率非常低。

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

离散的索引和连续的vector 离散的索引进行计算是没有意义的， 因为他们之间没有任何连续的关系

所以在embedding的时候才会要吧离散的索引转换成连续的vector 也就是dense vector

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Embedding 创建的是vocab size 的row 和vocab size的column 注意，embedding就是一个layer。 他跟linear layer都是一样的，都是layer。 例如我们调用Linear layer得时候：

self.dense = nn.Linear(input_dim, output_dim)是一样的。 self.embedding = nn.Embedding(vocab_size, embedding_dim) 都是在创建一个layer而已。

目的：从discrete tokens 到continuous vector的转换。 说白了他就像是q learning的一个lookup table。 每个文字都有对应的表格位置的value vector。

Row主要是代表每个word的index的 每个row对应的都是这个word的embedding。只是这里的编码方式是bigram，刚好让他的embedding和vocab size 是一样的了

我们每次对一个文字 或者一句话进行编码的时候。我们首先要获取的就是他的index 或者序列list。然后把这些通过去筛选row的号码， 才拉出来他对应的column的具体的embedding的column。

关于一些细节： 1. 随机的weights, shape 就是（vocab_size, vocab_size）embedding的初始化I是要对他产生的shape进行初始化的， 也就是embedding其实是初始化weights。 initialization： self.embedding.weight 时随机产生的。 这些weights是会在训练过程中更新的（updatable and learnable）

2.	value range 也就是这些weights,是你指定的。一般来说时uniform distribution 或者normal distribution。 
3.	具体的调用embedding来get每个word或者sentence的方法：
input_indices = torch.tensor([1, 2, 3]) embeddings = self.embedding(input_indices) print(embeddings)

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

关于def init(self, … ) 定义时候的问题

这个函数，在我们从别的class继承的时候，基本上都要写。 只要是在这里初始化的时候定义了的variable。也就是这里省略号的位置的variable。我们都需要在实例化这个class的时候，紧跟着对这些参数进行赋值，因为我们的class非常期待收到这些参数的值。 要注意的一点是， 这是关于class的定义，不是关于函数的定义，init__是一个非常特殊的函数，我们传递给他的varible .他会非常智能的自己传递给我们的class，所以相当于我们在class创建的时候，通过__init 可以拥有一大堆属于这个class的variable。 但是这些variable 的定义就需要在__init__里面专门定义。

import torch.nn as nn

class MyModel(nn.Module): def init(self, vocab_size): super(MyModel, self).init() self.embedding = nn.Embedding(vocab_size, vocab_size)

def forward(self, x):
    embedded = self.embedding(x)
    return embedded

实例化类并传递参数

vocab_size = 100 model = MyModel(vocab_size)

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

关于调用别人写好的函数，怎么指定参数： 一般文档里面会谢每一个Args的标准，也就是他的类型 比如说是int 或者是str，还有他是强制的variable 还是optional的。 一般来说我们仅仅需要强制性的。 然后我们给强制参数的时候，如果不写什么东西等于什么东西，他会按照文档规定的先后顺序来读取我们给他的variable。 所以要注意看文档。如果要指定某个特别的Args的参数，但是又不想一个一个的按照顺序写，就可以直接告诉他Args的keyword关键字，比如这个：nn.Embedding(1000, 64, padding_idx=0)

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Super（）的用法，还有class的继承 只要是想让class运行他们自己定义的__init__().就需要执行这个super().init()

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

nn里面都包含什么东西（torch） 各种layer： ⁃ nn.Linear ⁃ nn.Conv2d ⁃ nn.RNN ⁃ nn.LSTM ⁃ nn.GRU 各种损失函数 ⁃ nn.MSEloss ⁃ nn.CrossEntropyLoss 各种激活函数 ⁃ nn.ReLU ⁃ nn.Sigmoid ⁃ nn.Tanh

各种容器： ⁃ nn.Sequential （我们可能用到的） ⁃ nn.ModuleList

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

nn.Module 是啥意思（pytorch） 他是torch里面，专门负责nn的一个NN的模块的基础class。我们从它开始继承，就可以自动求导数了。因为里面有autograd， 还可以让我们简单的一层一层的写layer。

他还提供了forward 也就是向前传播，特别的简单。只需要继承这个class就好了。学会写继承其实很简单。

#torch #NN #autograd #NN_Module

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Positional encoding 主要是告诉model， 这个word和别的word相隔多远，这样的信息有时候对word来说很重要

在attention is all you need 里面。他把word 的embedding后面又加入了一个position embedding的vector（他们选择了size是512）。相当于把location加入进去了。

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

可能会用到的概率相关的东西 （ML/NN） sample space样本空间

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

New Note 图解 Word2vec – Jay Alammar – 一次可视化一个概念的机器学习。 — The Illustrated Word2vec – Jay Alammar – Visualizing machine learning one concept at a time.

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

输：one hot 

generated_text = [] for _ in range(100): # 生成100个字符 logits = model(idx) probs = torch.softmax(logits, dim=1) idx = torch.multinomial(probs, num_samples=1).item() generated_text.append(itos[idx]) print(‘‘.join(generated_text)) 

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

y=x 

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

右偏数据，数据在左侧集中，向右逐渐减少，符合指数分布的特性

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

propobility 在ML中必须掌握的点。 Probability Must-Knows for Machine Learning | Math for ML (Part 1)

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Zip的作用 可以把两个或者多个不同长度的list像是拉链一样， 一一对应起来。 然后我们可以用for去access他的每一个扣子里面的pair， 或者搞成一个list输出也行

list1 = [1, 2, 3, 4] list2 = [‘a’, ‘b’]

zipped = zip(list1, list2) print(list(zipped)) # 输出: [(1, ‘a’), (2, ‘b’)]

如果我们要access这个zip好的tuple 我们就可以用for z1, z2 in zip(w, w[1:]): 注意这里的z1, z2， 是两个数，而不是一个数。 如果只写了一个z1， 这样出来的效果就是一个（） tuple： (‘e’, ‘m’) (‘m’, ‘m’) (‘m’, ‘a’) 如果我们还想简化， 就可以说：

for ch1, ch2 in zip(c, c[1:]): print(ch1, ch2)

这样出来的结果就是： e m m m m a

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

slicing 冒号： words[:10] 第11个的位置是不保罗/或者说index索引是10的element是不包括的， 因为是从0开始计数。 words[10]就是提取index是10的元素

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Min(), max () sum()等等是接受iterable的对象的，所以当我们用len(i) for I in …这种generator… Min(), max () sum()等等是接受iterable的对象的，所以当我们用len(i) for I in …这种generator的时候，他产生的一一连串可以iterate得对象，所以我们就可以在外面嵌套min, max, sum .

同时，他们也都接受list作为参数，所以两种写法都是对的。 words = [“apple”, “banana”, “cherry”]

使用列表推导式

min_length = min([len(i) for i in words]) print(“Minimum length using list comprehension:”, min_length)

使用生成器表达式

min_length_gen = min(len(i) for i in words) print(“Minimum length using generator expression:”, min_length_gen)

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Str.splitlines()可以把输入的str的空格消掉，也就是将str搞成只有word的一个新的list 所以他的两个功能： 1. Txt 消除空格 2. Str 变成list 方便进行操作

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Negatively log likelihood loss 就是cross entropy loss 公式都是一模一样的，只是说cross entropy loss是更加fancy的说法。 likelihood就是要乘以概率的意思

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Batch size 是啥意思 就是每次都有四条数据 同时进行训练，每一个都是独立的，可以在我们的subprocess上面进行训练

非常简单的例子 如果模型有100条的数据，batchsize是4， 那么我们的模型就会有100/4 ‎ = 25个批次。

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

一句话的序列，怎么一个一个往后推来做训练数据  

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

training的时候 要保证是random samplized

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

tokenizor 用来对人们说的话进行编码的手段。

Google用的是sentence piece tokenizor OpenAI 用的是tick token （BPE）（bit pair entokenior） GPT就是用的这个

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

validation的重要性 主要是要提到 防止overfitting

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Lambda 的用法 （匿名函数） 如果你说某一个variable事一个lambda，那么你就是说它是一个函数。 所以你可以用你的这个variable对一些新的value进行操作！

就是先输入变量， 冒号后面就是利用这两个变量产生的操作：

不用定义return， 也不用放变量在括号里面

add = lambda x, y: x + y

Result = add(3, 5)

我们用它就是因为它简单。 写起来很快

比较难的用法是gpt里面对character进行encoding的用法：

encode = lambda s: [stoi[c] for c in s] 这里的s就是随便输入的txt文本。所以我们可以用for对他进行操作。 等他们的for操作完了之后，再用stpi[c]对所有的c进行操作。这里唯一的变量就是输入的s。

另外一个比较难的例子： decode = lambda l: ‘‘.join(itos[i] for i in l )

#lambda #python

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

字典dictionary的创建 my_dict = {‘a’: 1, ‘b’, :2 ‘c’:3} 字典的形式直接就是中括号，然后里面是一对一对的。 每一对都是逗号隔开的 然后前面的是key ，key 冒号： value就是他的value

或者可以把list搞成字典：

pairs = [(‘a’, 1), (‘b’, 2), (‘c’, 3)] my_dict = dict(pairs) print(my_dict)

或者这种形式的也可以：(gpt就是这么搞的character，把每个character 都弄成了字典)

keys = [‘a’, ‘b’, ‘c’] values = [1, 2, 3] my_dict = {k: v for k, v in zip(keys, values)} print(my_dict)

要想获取dict里面的value，可以用这种方法： my_dict[k]

如果想要搞一个完整的string 就可以参照这样的写法： encode = lambda s: [stoi[c] for c in s] Decode = lambda l: ‘’.join([itos[i] for i in l]

#python #dictionary #gpt #list #enumerate

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Enumerate 返回的值是可以iterate的，也就是可以用for来处理他的返回value。所以for i, j in enumerate… Enumerate 返回的值是可以iterate的，也就是可以用for来处理他的返回value。所以for i, j in enumerate（…）是合理的

一个简单的例子： #string to integer (encoding) stoi = {i: w for i, w in enumerate(chars)}

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

iPad可以看网页学习，连商场的wifi。mac连自己的热点，ipad在左边，充电线插在右边。iPhone在左边，充电线在左边。… iPad可以看网页学习，连商场的wifi。mac连自己的热点，ipad在左边，充电线插在右边。iPhone在左边，充电线在左边。 Ipad稍稍往全面挪，挪到靠近自己的手的位置。 iPad的YouTube可以在Safari上面看，最大屏幕，然后把翻译软件悬浮放在最左边。

音量，mac一定要静音，ipad连上森海塞尔的耳机。

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

decoding encoding 字符来做chatgpt， 做成字典的样子（正反字典），用enumerate 把list做成字典，要用enumerate

这个例子： text = “hello world” chars = sorted(list(set(text))) vocab_size = len(chars) print(vocab_size) # 输出: 8

创建字符到索引的映射字典

stoi = {ch: i for i, ch in enumerate(chars)}

打印结果

print(stoi) # 输出: {‘ ‘: 0, ‘d’: 1, ‘e’: 2, ‘h’: 3, ‘l’: 4, ‘o’: 5, ‘r’: 6, ‘w’: 7}

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

set{}转换成list  

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

切片操作 也就是： 不只有在numpy array时可以用的，python的字符串r和list都可以用 text = “Hello, world!” print(text[7:]) # 输出: “world!” print(text[:5]) # 输出: “Hello” print(text[3:8]) # 输出: “lo, w” print(text[:]) # 输出: “Hello, world!”

len(text) print(text[:100]) print(type(text))

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

ASCII和utf-8 的区别 ASCII就是美国的标准，主要就是能理解和解读英语和他的一些标点符号 ASCII（American Standard Code for Information Interchange）

Utf-8是为了中文，韩文，日文，法语的一些重音，甚至还可以包括表情符号。。准备的 所以为了让计算机能够理解我们下载的txt等信息，最好就是用encoding=‘utf-8’

UTF-8 的全称是 “Unicode Transformation Format - 8-bit” （这就有点像是联合国的标准）

如果搞错了，不用encoding=‘utf8’ 可能就会出现乱码

#ASCII #utf-8 #encoding

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Open（文件位置，mode=‘r/w/x’/a, encoding=‘utf-8’) as f: Mode 的r是read ，就是读文件 ，一般情况下 我们read就够了

W是write，就是会对这个文件进行操作，改写

x就是创建一个新文件，然后往里面写东西

a就是append， 在文件后面append东西

Utf-8

#python #mode #encoding #utf-8

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

with （python里面的意思） 主要是在打开文件的时候， 确保文件在使用之后会自动关闭 with open(‘example.txt’, ‘r’) as file: content = file.read() print(content)

文件在这里自动关闭

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

subprocess 主要是一个python的module block 也就是用来运行command line的 他可以执行一些在terminal才可以执行的命令 这里有个例子，让他执行wget 网页下载到当前文件夹的命令

import subprocess

url = “https://raw.githubusercontent.com/karpathy/char-rnn/master/data/tinyshakespeare/input.txt” subprocess.run([“wget”, url])

这个跟直接在terminal写wget的命令产生的效果是一样的 只不过他可以让我们在python的一个文档里面执行这个命令 方便灵活了很多 !wget https://raw.githubusercontent.com/karpathy/char-rnn/master/data/tinyshakespeare/input.txt

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Wget的用法，主要是从www上面拿一些数据，比如txt或者csv 主要他会吧这个文件下载到当前文件夹

要想在Jupyter notebook运行这个wget的命令，前面要加上！ 因为他是command line的命令

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

seed 主要是想把所有devices产生随机数的seeds设置起来，让实验可以重复

在torch上可以这样说：

Torch.manual_seed(1337)

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Torch 他和tensor flow事不同的架构了。也是做NN的，可以用来做gpt，我学了一个教程就是用的他做的gptfrom scratch。

torch是Facebook团队开发的

https://www.youtube.com/watch?v=kCc8FmEb1nY&t=4454s

#torch

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

argmax的例子： 当然可以。让我们通过一个具体的例子来说明 np.argmax 在一个 4x4 矩阵上的操作，并解释其输出和变化。

示例：对一个 4x4 矩阵进行 argmax 操作

假设我们有一个 4x4 的矩阵，我们想要找到每行中最大值的索引。

例子矩阵

import numpy as np

# 示例矩阵
matrix = np.array([
    [1, 3, 2, 4],
    [5, 1, 6, 2],
    [4, 3, 2, 1],
    [7, 8, 5, 6]
])

print("Matrix:")
print(matrix)

沿行进行 argmax 操作（即 axis=1）

使用 np.argmax 沿着每一行（axis=1）进行操作：

# 沿着每行进行 argmax 操作
row_argmax = np.argmax(matrix, axis=1)

print("\nArgmax along rows (axis=1):")
print(row_argmax)

沿列进行 argmax 操作（即 axis=0）

使用 np.argmax 沿着每一列（axis=0）进行操作：

# 沿着每列进行 argmax 操作
column_argmax = np.argmax(matrix, axis=0)

print("\nArgmax along columns (axis=0):")
print(column_argmax)

代码和输出解释

让我们运行上述代码并解释输出：

import numpy as np

# 示例矩阵
matrix = np.array([
    [1, 3, 2, 4],
    [5, 1, 6, 2],
    [4, 3, 2, 1],
    [7, 8, 5, 6]
])

print("Matrix:")
print(matrix)

# 沿着每行进行 argmax 操作
row_argmax = np.argmax(matrix, axis=1)
print("\nArgmax along rows (axis=1):")
print(row_argmax)

# 沿着每列进行 argmax 操作
column_argmax = np.argmax(matrix, axis=0)
print("\nArgmax along columns (axis=0):")
print(column_argmax)

输出结果

Matrix:
[[1 3 2 4]
 [5 1 6 2]
 [4 3 2 1]
 [7 8 5 6]]

Argmax along rows (axis=1):
[3 2 0 1]

Argmax along columns (axis=0):
[3 3 1 0]

解释

• 沿行进行 argmax 操作（axis=1）：
  • 对于第一行 [1, 3, 2, 4]，最大值是 4，其索引是 3。
  • 对于第二行 [5, 1, 6, 2]，最大值是 6，其索引是 2。
  • 对于第三行 [4, 3, 2, 1]，最大值是 4，其索引是 0。
  • 对于第四行 [7, 8, 5, 6]，最大值是 8，其索引是 1。
  • 所以结果是 [3, 2, 0, 1]。
• 沿列进行 argmax 操作（axis=0）：
  • 对于第一列 [1, 5, 4, 7]，最大值是 7，其索引是 3。
  • 对于第二列 [3, 1, 3, 8]，最大值是 8，其索引是 3。
  • 对于第三列 [2, 6, 2, 5]，最大值是 6，其索引是 1。
  • 对于第四列 [4, 2, 1, 6]，最大值是 6，其索引是 0。
  • 所以结果是 [3, 3, 1, 0]。

总结

通过 np.argmax(matrix, axis=1)，我们可以找到每行最大值的索引，输出形状为 (4,)，表示每行最大值的索引。通过 np.argmax(matrix, axis=0)，我们可以找到每列最大值的索引，输出形状也是 (4,)，表示每列最大值的索引。

希望这个例子能帮助你理解 argmax 的操作和输出形状。如果有其他问题或需要进一步解释，请告诉我！    

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

PDF 是概率密度函数 他的积分是概率 均匀分布（0-1）是说在0到1的区间，pdf的value是1 。 也就是说在这个区间内的所有点的pdf都是1. 他们这个区间的integral 也就是面积，或者积分，是1.

想要计算均匀分布的概率，直接就是b-a。 • PDF 的值是 1：表示在 [0, 1) 区间内每个点的概率密度是 1。 • 概率的计算：通过积分计算区间 [a, b) 内的概率，结果是 b - a。

#uniform_distribution

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Z就是我们说的logits 最后一层的activation就是对Z 也就是logits 做的激活。

为什么有的时候模型会让他自己输出，而不是再套一层softmax的activation，gpt的解释是： 数值稳定性：直接处理 logits 可以避免在计算 softmax 时的数值不稳定问题

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Dense layer 全连接层 -（针对分类问题的，也就是categorical） 主要是针对categorical 的分类问题，最后一层一般都是这个dense layer。 也就是用activation是softmax，把问题最后转换成概率问题输出，也就是每个category的概率。nice

如果model.add(layers.Dense(10)) 他没有写activation，也就是说没有activation，

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

batch normalization layer 他就是对每一个batch进行normalization的操作。直接可以添加到层与层之间，我们在input layer之后，一般都会对他进行normalization的操作。 这里是好处：• 概念：在每个小批量上标准化输入，使得每层输入具有零均值和单位方差，并且引入缩放和平移参数。 • 好处： • 加速训练 • 减少内部协变量偏移 • 具有正则化效果 • 降低对输入数据预处理的依赖性

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Tensorflow keras的关系 keras是tensorflow下面的关于NN的API，主要是提供DL的深度学习libreary的。 tensorflow是keras的框架。

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

fork别人的repo，在GitHub 首先要进去别人的GitHub 然后在页面上fork 一个自己的，然后进入自己的github里面的fork， clone自己的那个网址。再去CODE里面就好了。

这样不会影响到别人的分支

。具体步骤在这里：   #fork #github #clone

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

RNN LSTM 对于轨迹的预测 其实轨迹和word是一样的 只不过我们的轨迹是2维度，（现在我们需要加入第三个维度，比如说别的车辆为他施加的影响） 这个过程叫做embedding

这个车辆之前的position（word）会对之后的position（word）产生影响

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

matrix multiplication和dot product的关系 

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Dot product 点积  

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Eigenvectors and Eigenvalues 

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

inverse matrix逆矩阵      只要determinant of A不是0， 就会有x存在 

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Equation 等式转换成matrix的方法  

 

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Cross entropy loss function 交叉熵损失函数和softmax 的组合 来确定预测出的标签和实际标签的概率… Cross entropy loss function 交叉熵损失函数和softmax 的组合 来确定预测出的标签和实际标签的概率差多少（categorical 会被one hot encode，所以是可以用概率来表示的）

cross entropy：他就是cost

讲这个问题讲得很清楚的网站： https://www.youtube.com/watch?v=6ArSys5qHAU

因为exponential function的导数就是他本身，然后log（e**x）） 就是x 所以才会用到cross entropy 的这个方法，也就是 通过抵消e，来让我们softmax算出来的概率直接就等于实际概率了。 Softmax的函数是这样的： 

用cross entropy 计算出的cost function 是这样的：  其中a就是每个neuron的activation，在最后一层，也代表了每个neuron预测的概率，也对应了每个标签可能的概率。

#cost_function #cross_entropy #softmax

Log 的一个重要特征，就是概率（0-1）之间的数字，他算出来的value都是负，所以cross entropy 才会在log前面加上减



🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

常用函数和他的导数 Log(x) e**x Tanh ReLU Sigmoid(x) 

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

常用函数和他的导数 Log(x) e**x Tanh ReLU Sigmoid(x)

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

neuron和weight 之间的点亮方式 记住 就是A = WA（L-1） + B

点亮neuron的weight 永远在neuron前面

就像图上画的那样

 也就是说，别管第一层输入层，我们就从第一层weights 和bias入手就好了。



🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Sigmoid function 把-无穷大到正无穷转化到0-1区间 的squishification function 也叫logistic curve， 公示：

Activation function 会用它来做，这样才方便知道或者说比较哪一个neuron被点亮了。 因为我们统一了标准  Sigmoid 的符号：  #Sigmoid

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

neuron是什么 neuron是一个cell，hold一个数字0-1 数字越大，越亮。所以你可以把它理解为亮度。 或者你可以把它理解为activation，activation越大，证明这个neuron九月activate。就越活越。

NN中的hidden layer的某一个neuron，说不定就代表了图片中的某一种的比较明显的特征，比如说粗眉毛，大鼻子。

#neuron #weight #bias #NN #activation_function

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

weight 和bias Weight主要就是说这个neuron和neuron之间的联系有多紧密 Bias就是说，这个neuron需要点到多么亮，或者需要超过多少value，这个neuron才会被点亮。

#weight #bias

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Back propagation 的calculus 微积分的运算逻辑 + 为什么不能直接求导为0-》解决思路是gradient… Back propagation 的calculus 微积分的运算逻辑 + 为什么不能直接求导为0-》解决思路是gradient descent

https://www.youtube.com/watch?app=desktop&v=tIeHLnjs5U8

Back propagation 得目的就是找出让cost function 变化最大的variables， 包括weight 和bias in each layer

cost是关于weight 和bias的一个function 可以写成这样： 

我们在backpropogate的时候，是从后往前推进的，也就是说，要从cost 推进向前的activation2， activation1 等等

Cost 的计算：最后一层输出的（最后一层的activation（softmax） - groundtruth y）**2 

activation的计算方式： activation是由weight，bias，还包括了前一层的activation（sigmoid function： ReLU /Tanh等等组合成为的）， 这里的sigmoid的符号，就是代表的activation使用的function了。  在没有activation之前，可以吧weight ， bias， 还有前一层的activation的这个表达式用一个简单的符号Z来表示：  总结起来，看起来这个结构就是这样的： 其实y就是一个标签，我们把这个标签one hot encode之后， 其实 跟soft（weight， bias， activation上一层）这个公式产生的0-1之间的概率matrix就可以进行比较了。这就是精髓吧。 所以其实y就是一个关于activation（Z）的概率矩阵罢了，只不过他是真实的label的概率矩阵。我们通过比较真实的概率矩阵和我们瞎算出来的概率矩阵进行对比，算他们的差值的平方，就可以得出cost了。

值得注意的是，我们老是提及到activation，其实activation你仔细观察，也就是关于weight和bias的function而已，只不过他是上一层的weight和bias，仅此而已。 所以我们才会用chain rule来解决问题。 因为 Cost 降低的最厉害的地方，恰恰就是我们需要求导数的地方。 也就是对于multivariable求导数，这里的multivariable就是weight 和bias。 不过这些weight 和bias，在每一层，有每一层的名字和subscript，superscript。

是不是说求出来的导数后，令他等于0， 我们就能找到最优的weight了呢？

并不是的！ 因为cost 函数一般来说都不是一个凸函数（non-convex）， 所以不一定能找到最优解，也就是它存在多个最小值。 我们会陷入局部最优。 我们根本找不到一个简单的凸函数的全局最小值。在这种情况下，我们是没有办法简单的让导数为零来求解最优解weight和bias的。因为回求出很多歌局部最小值，而且计算的成本会非常的高。 为了解决这个问题，我们才用到了gradien descent，梯度下降. 其实gradient descent的目的也是更新weight 和bias，只不过他是通过计算机擅长的方式来更新。他跟learning rate非常相关。 而且核心是，他也用到了导数derivative。 这也是为什么我们一开始要initialize weight和bias， 因为我们会根据这些weight和bias的concrete value来一步一步的计算下一个step的weight和bias，再更新。 梯度下降的公式是这样的：

weight 的更新：

bias的更新  这里的alphaW：叫做derivative W，也就是W的一个小小的变动（nudge）

 Chain rule 在这个时候就会派上用场： 主要是从cost推导到w的过程，中间要经历activation， Z， 最后才能到达W 具体公式是这样的： 主要是看下标， 因为Lsuperscript代表的是这一个layer。 下标subscript代表的才是求偏导数（relevant derivatives）的过程

也就是说，对于activation， Z， 和w的偏导数，都要求出来。他们都叫做偏导数，relevant derivative



具体的计算过程是这样的： 你可以看看分子moninator都是什么样的： moninator 分母demoninator就是activation， Z ， 和W。   这里的chain rule实际上已经包含了展开式了，特就是睡每一项分子对于分母来说才是变量，每一项都不是一weight和bias为核心的，这样会帮助我们简化运算。liyongchain rule来做事情，会让计算过程明确。因为每一步的relevant derivative是非常容易求的。 对于activation对于Z的导数，你觉得Z是应该展开成weight吗？ 其实并不是，因为我们不是求activation对于Z里包含的weight的导数，我们只是求action对Z的导数。 所以才会变得简单。 至于Z对于activation的导数。你会发现chain rule已经在第一项乘进去了，这就是奥义。

这样的过程，对于每一个example的training example，也就是每一条数据，都需要求。所以最后表达出来的过程就是要averaging所有的这些偏导数 relevant derivatives。 这个就叫做 derivative of full cost function： 总的损失函数的导数。



更夸张的是， 注意这里的W。他仅仅代表的是梯度向量的一个分量。。

梯度向量长什么样的shape？ ⁃ 首先他是matrix ⁃ 其次他是由weight和bias相对于cost组成的，也就是cost对于每一个神经元上的他们的偏导数组成（built up from partial derivatives）的。也就是relative derivative（相对于weight和bias 来说) 注意： 这里的deltaC就是gradien vector的样子

⁃	

对于cost 对于bias的cain rule的计算（bias 对于cost的改变贡献的程度（ratio））



对于不同layer和不同的neuron的偏导数 partial derivatives， 仅仅就是下标不同，可以同时表示不同的neuron，不同的layer罢了。 下标subscript就是表示的neuron的位置，上标表示的是superscript：  注意，这个chain rule的第一项已经不是weight了。卫视上一层的activation 因为是层层相连的： 也就是说上一层的activation出来了之后，连接了Z， Z再链接了下一层的activation。 再链接下一层的Z， 最后才是cost。 所以看这个公式应该从后往前看。 注意这里的C0，代表的就是输出的数字labeled的数量，如果你让她检测0-9的数字，那么就是检测出来的图片等于0号位置的概率。 （one hot encode 让他等于1了）

J在这里代表的就是输出label的数量。也就是每个label都需要一个单独的j来表示。 也就是预测出来的数字等于每一个位置上的数字的概率是多少，然后再把它们取差值的平方。 这里j的范围就是多少的神经元，可以看出来L层的神经元的数量是n。然后因为每个神经元的计数是从0开始的，所以才要减去1. 所以求和公式主要是说。对于L层的每一个神经元。我们都要求cost。 我觉得最后一层神经元的数量应该等于label的unique的数量。

每一个neuron都会被很多歌来自 上一层L-1的neuron同时影响，随意为了表示这样的影响，我们要用两个下标来表示，上一层的那个neuron，还有这一层的哪个neuron：一般来说，上一层的每一个neuron都会对这一层的neuron产生影响。



这个图里面的k就是来自上一层L-1 的第k的neuron J表示的是我们正在访问的这个neuron。 所以写成了jk，而不是kj的形式。 如果看不懂，可以看看3b1b在第一个part讲的关于weight的shape的视频。 https://www.youtube.com/watch?v=aircAruvnKk&t=505s

具体来说，这些weights和bias组成了一个Z：

 可以从第三项举例子来看到，neuron的计数是从0开始的。 这里的W（j2）代表的就是现在我们研究的第L层的第j个neuron， 我们要让上一层的L-1层的2号，也就是第三个neuron对他产生的影响（weight ）

你可以看到这个Z的公示，如果写的更加抽象一点：



唯一需要注意的就是这个chain rule的第一项，不再是位于weight的偏导数partial derivative，而是对雨上一层的activation了。因为它让我们能够组成更长的链条。

#gradient_descent

#relevant_derivative

partial_derivative

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Integral 积分f （calculus 微积分） 积分f（integral）和derivative（d..）是彼此的inverse （逆）

Derivative -> antiderivative -> integral->antiintegral-> derivative

#calculus #integral

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

uniform distribution 和 normal distribution 一个是均匀分布， 一个是正态分布

均匀分布就是所有位置的事件，发生的概率都是一摸一样的

正态分布是发生的概率在均值附近的可能性最高，对着离均值越来也远，发生的概率逐渐降低。他主要是由mean和方差variance来决定的。标准的正态分布是均值是0， 方差是1 。

#uniform_distribution #normal_distribution #propobility

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

np.random.rand()的用法 用来产生uniform distribution over [0, 1]的随机数的 注意里面接受的直接是维度，比如说np.random.rand(3, 4) 而不是写成np.random.rand((3, 4)) 第第二种写法，只有在one 和zero矩阵的生成syntax才是对的

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Help的用法 help(“assert”)

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Assert 检查是否位true，如果不是 会反回错误消息 assert condition, “Error message”

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Buffer 是什么意思（缓冲区） 是临时存储数据的一个地方/或者更专业一点叫做区域或者结构

memory buffer

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Linux command line 的命令

1. 删除folder rm -r PATH

这里的r是recursive的意思，因为是remove的folder ，所以要recursive

或者rm -rf PATH 这里的f 是force 强制

2.	Unzip a zip file  Unzip FILENAME.zip 

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Linux 本地访问Kaggle 数据

1. 在kaggle拿到API
   1. 把API放在linux该放的位置
   2. chmod to 600
   3. 利用kaggle 下载数据的命令下载即可

一般来说，data 都会在某一个ipynb的开头几行就能找到。 （kaggle的site里面

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Multivariable function多变量函数 , partial derivative偏导数, gradients梯度  Vector 是有方向的， 一般写成column的形式， 点是没有方向的，就用parentheses 来写的。 vector是用来展示motion的。 Tensor是三维空间的vector。 



🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

导数 derivative Derivative 描述的是两点之间的变化 瞬时速率（instanteneously change）描述的只是一个点的瞬时value 这两个东西是不一样

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

1500 mile ‎ = 2,414.016 kilometers 1 mile ‎ = 1.60934 kilometers

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

MNIST NN digits detection from scratch 

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

One hot encoding 对于 MNIST DATSET的实现。 主要是对Y label的coding 把它转化成matrix… One hot encoding 对于 MNIST DATSET的实现。 主要是对Y label的coding 把它转化成matrix的形式 

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

向量的维度混淆 我一直觉得vector是1维的，matrix是2维的 从某种意义上来说，是对的。 但是涉及到NN的操作。是错的

我感觉b的维度理解，也就是他的dimentiona 就错在这个误区。之前的理解太肤浅，太宏观。跟NN的具体操作差太多了。 要充分理解他们对于b的广播机制的使用。



可是为什么我们经常看到的NN的图例，每一个layer的neuron都是竖着排列的呢，然后那个neuron的bias都会跟着他一起竖着排列。 难道这不是说明bias是列向量吗？ 因为是竖着的？ 

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-07-27-我想知道为什么你可以把m写在h的前面，难道维度m不是每个数据的第二维度的标志吗？你把它写在第一位是什么意思…

2024-07-27-我想知道为什么你可以把m写在h的前面，难道维度m不是每个数据的第二维度的标志吗？你把它写在第一位是什么意思呢？

---

layout: post title: ‘我想知道为什么你可以把m写在h的前面，难道维度m不是每个数据的第二维度的标志吗？你把它写在第一位是什么意思呢？ ‘ date: 2024-07-27T12:05:58-04:00

---

权重矩阵维度的解释

在神经网络中，权重矩阵的维度表示了输入特征与神经元之间的连接。对于你提到的情况，让我们详细解释为什么权重矩阵 (W_1) 的维度是 (m \times h)，以及为什么这种表示方式是合适的。

输入层到隐藏层的权重矩阵

假设有以下结构：

• 输入层有 (m) 个特征。
• 隐藏层有 (h) 个神经元。

权重矩阵 (W_1) 的维度

权重矩阵 (W_1) 的维度是 (m \times h)。这是因为：

• 行数 (m)：表示输入层的特征数量，每一行对应一个输入特征。
• 列数 (h)：表示隐藏层的神经元数量，每一列对应一个隐藏层神经元。

这种表示方式意味着每个隐藏层神经元都有 (m) 个权重（对应于每个输入特征），这些权重一起决定了该神经元的输出。

矩阵的计算

在前向传播中，计算隐藏层的输入和输出如下： [ Z_1 = XW_1 + b_1 ]

其中：

• (X) 是输入数据矩阵，维度为 (n \times m)，(n) 是训练样本的数量，(m) 是每个样本的特征数量。
• (W_1) 是权重矩阵，维度为 (m \times h)。
• (b_1) 是偏置向量，维度为 (1 \times h)。

通过矩阵乘法，(XW_1) 的维度为 (n \times h)。这意味着每个样本经过权重矩阵变换后，会产生 (h) 个值（对应隐藏层的每个神经元的输入）。

为什么是 (m \times h)

这种表示方式的原因可以归结于矩阵乘法的规则和神经网络的结构：

• 矩阵乘法规则：矩阵 (A) 的维度是 (n \times m)，矩阵 (B) 的维度是 (m \times p)，它们的乘积 (AB) 的维度是 (n \times p)。为了保证矩阵乘法 (XW_1) 有效，输入矩阵 (X) 的列数（即特征数量 (m)）必须等于权重矩阵 (W_1) 的行数（即输入特征数量 (m)）。
• 神经网络的结构：在神经网络中，输入层的每个特征与隐藏层的每个神经元都有连接。权重矩阵的每一列代表一个隐藏层神经元的所有权重，而每一行代表一个输入特征的所有权重。因此，权重矩阵 (W_1) 的维度自然是 (m \times h)。

例子

假设我们有以下数据和权重矩阵：

• 输入矩阵 (X)（2个样本，每个样本3个特征）： [ X = \begin{bmatrix} x_{11} & x_{12} & x_{13}
  x_{21} & x_{22} & x_{23} \end{bmatrix} ]
• 权重矩阵 (W_1)（3个输入特征，2个隐藏层神经元）： [ W_1 = \begin{bmatrix} w_{11} & w_{12}
  w_{21} & w_{22}
  w_{31} & w_{32} \end{bmatrix} ]

矩阵乘法 (XW_1)： [ XW_1 = \begin{bmatrix} x_{11} & x_{12} & x_{13}
x_{21} & x_{22} & x_{23} \end{bmatrix} \begin{bmatrix} w_{11} & w_{12}
w_{21} & w_{22}
w_{31} & w_{32} \end{bmatrix} = \begin{bmatrix} z_{11} & z_{12}
z_{21} & z_{22} \end{bmatrix} ]

这意味着每个输入样本经过权重矩阵变换后会产生2个值（对应隐藏层的2个神经元的输入）。

总结

• 权重矩阵 (W_1) 的维度为 (m \times h) 是因为每个隐藏层神经元需要与所有输入特征连接。
• 这种表示方式符合矩阵乘法的规则，确保前向传播计算中的维度一致。
• 偏置向量 (b_1) 的维度为 (1 \times h)，表示每个隐藏层神经元对应一个偏置。

通过这种方式，我们可以清晰地表示和计算神经网络中各层之间的连接和转换。

#NN #weight #bias #shape #neuron #feature

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

NN的权重矩阵，shape，bias的shape 他代表的是输入特征雨神经元之间的连接 而不是每个数据的条数与神经元的连接

Bias则是附加在每个神经元上的bias的value 所以shape上来看，  这句话我觉得特别有用。 这里b是个vector，是1*h的shape 也就有了意义。他的shape只跟neuron的多少有关系。跟前面的feature，训练数量等等的都没关系。  这里就说明了，每一行就是一个特征对应的权重，每一列就是一个神经元的权重。 

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

R 的n次方表示的是实向量空间（real vector space） real number 就是实数

这里是gpt的解释：

微积分在矩阵上的作用

在神经网络（NN）中，微积分确实广泛作用于矩阵上。这种操作非常常见，尤其在训练过程中。以下是微积分如何作用于矩阵以及在NN中的具体应用：

微积分在矩阵上的操作

1. 梯度计算：
   • 梯度：梯度是一个向量，表示某个函数在各个变量方向上的偏导数。在神经网络中，损失函数 (L) 对权重矩阵 (W) 和偏置向量 (b) 的梯度是微积分的主要应用之一。
   • 反向传播（Backpropagation）：利用微积分的链式法则，计算损失函数相对于每层权重和偏置的梯度。
2. 矩阵微积分：
   • Jacobian 矩阵：表示向量值函数的偏导数矩阵。
   • Hessian 矩阵：表示标量值函数的二阶偏导数矩阵，用于优化算法中的二阶信息。

微积分在神经网络中的应用

1. 前向传播（Forward Propagation）：
   • 计算每层的输出，主要涉及矩阵乘法和激活函数的应用。
   • 每层的输出 (Z) 是上一层输出 (A) 与权重矩阵 (W) 相乘，再加上偏置 (b)： [ Z = A \cdot W + b ]
   • 然后通过非线性激活函数 (f) 得到下一层的输入： [ A = f(Z) ]
2. 反向传播（Backpropagation）：
   • 计算损失函数 (L) 对每个参数的梯度。
   • 使用链式法则将误差从输出层传播回输入层： [ \frac{\partial L}{\partial W} = \frac{\partial L}{\partial Z} \cdot \frac{\partial Z}{\partial W} ]
   • 其中 (\frac{\partial L}{\partial Z}) 是损失函数对输出层输入的梯度，通过前向传播的反向传播计算得到。
3. 梯度下降（Gradient Descent）：
   • 更新参数，使损失函数最小化： [ W \leftarrow W - \eta \frac{\partial L}{\partial W} ]
   • 其中 (\eta) 是学习率。

线性代数中的 (\mathbb{R}^n)

在线性代数中，(\mathbb{R}^n) 表示 (n) 维实数向量空间。它的意思是所有 (n) 元有序实数数组（向量）的集合。例如：

• (\mathbb{R}^1)：表示一维实数线。
• (\mathbb{R}^2)：表示二维平面上的所有点。
• (\mathbb{R}^3)：表示三维空间中的所有点。

在神经网络中，输入数据和参数通常可以看作是高维实数空间中的向量或矩阵。理解这些概念有助于理解神经网络的结构和操作。

英文解释

In linear algebra, (\mathbb{R}^n) represents the (n)-dimensional real vector space. This notation signifies the set of all ordered (n)-tuples of real numbers (vectors). For instance:

• (\mathbb{R}^1): Represents the real line (one-dimensional space).
• (\mathbb{R}^2): Represents the plane (two-dimensional space).
• (\mathbb{R}^3): Represents the three-dimensional space.

In the context of neural networks, the input data and parameters are often viewed as vectors or matrices in high-dimensional real spaces. Understanding these concepts helps in grasping the structure and operations of neural networks.

综述

1. 线性代数和微积分的结合：
   • 神经网络训练过程中，线性代数用于数据和参数的表示和操作，微积分用于优化这些参数。
   • 微积分通过计算损失函数的梯度来指导参数更新，以最小化损失。
2. (\mathbb{R}^n) 的解释：
   • 表示 (n) 维实数向量空间，是理解神经网络数据表示的基础。

掌握线性代数和微积分对于深入理解和优化神经网络至关重要。两者的结合使得神经网络能够高效地处理和学习复杂的数据模式。

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Linear Algebra: linear combination of two vectors 就是向量的加 和乘法， 这样生成的蓝色的新的vector，可以在space的任意位置。或者换句话说span of these two vectors is all vectors of 2D space

 #linear_algebra

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Linear Algebra：Vector 的变换 Scaling，就是加法，或者乘法 ， scalar就是一个标量的变换。 乘一个负数就是让他反向scaling。 Scale的多少就是乘的那个数的大小。

注意，scalar就是number比较fancy的说法。其实本质上都是一样的，根本就没有方向。

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

如果非要熬夜，三个小时是最划算的睡眠时间， 可以完全恢复，下次熬夜可以试试，要不然就是4.5，或者6，或者7.5个小时。 每次间隔… 如果非要熬夜，三个小时是最划算的睡眠时间， 可以完全恢复，下次熬夜可以试试，要不然就是4.5，或者6，或者7.5个小时。 每次间隔1.5个小时就可以。

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

iPad用来打开chatgpt和google translate Mac 用来看视频

现在Mac 新增加视频是不行的，因为一旦全屏，ipad就会黑屏。这是一个bug。。。 所以就只弄鼠标连接就好了。

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-07-26-点乘和matrix 乘以matrix 有什么不一样吗？ 什么时候该用什么点乘，什么时候该用matrix乘法…

2024-07-26-点乘和matrix 乘以matrix 有什么不一样吗？ 什么时候该用什么点乘，什么时候该用matrix乘法呢？

---

layout: post title: ‘点乘和matrix 乘以matrix 有什么不一样吗？ 什么时候该用什么点乘，什么时候该用matrix乘法呢？’ date: 2024-07-26T11:37:35-04:00

---

点乘（Dot Product）与矩阵乘法（Matrix Multiplication）

点乘和矩阵乘法是线性代数中的两种基本运算，它们用于不同的场景并且具有不同的计算规则和用途。

点乘（Dot Product）

点乘是两个向量之间的操作，计算结果是一个标量。它主要用于计算两个向量之间的投影或相似度。

公式： 如果有两个向量 (\mathbf{a}) 和 (\mathbf{b})： [ \mathbf{a} = \begin{bmatrix} a_1 & a_2 & \cdots & a_n \end{bmatrix} ] [ \mathbf{b} = \begin{bmatrix} b_1 & b_2 & \cdots & b_n \end{bmatrix} ] 那么它们的点乘是： [ \mathbf{a} \cdot \mathbf{b} = a_1 b_1 + a_2 b_2 + \cdots + a_n b_n ]

用途：

1. 计算相似度：在机器学习中，点乘用于衡量两个向量（如特征向量或嵌入向量）的相似度。
2. 投影：点乘用于计算一个向量在另一个向量方向上的投影。
3. 物理应用：在物理中，点乘用于计算力和位移的关系（如功的计算）。

矩阵乘法（Matrix Multiplication）

矩阵乘法是两个矩阵之间的操作，结果是一个新的矩阵。它用于线性变换的组合以及多维数据的变换。

公式： 如果有两个矩阵 (\mathbf{A}) 和 (\mathbf{B})，其中： [ \mathbf{A} = \begin{bmatrix} a_{11} & a_{12}
a_{21} & a_{22} \end{bmatrix} ] [ \mathbf{B} = \begin{bmatrix} b_{11} & b_{12}
b_{21} & b_{22} \end{bmatrix} ] 那么它们的矩阵乘法是： [ \mathbf{C} = \mathbf{A} \cdot \mathbf{B} = \begin{bmatrix} a_{11}b_{11} + a_{12}b_{21} & a_{11}b_{12} + a_{12}b_{22}
a_{21}b_{11} + a_{22}b_{21} & a_{21}b_{12} + a_{22}b_{22} \end{bmatrix} ]

用途：

1. 线性变换：矩阵乘法用于表示和组合线性变换，例如旋转、缩放和投影。
2. 数据变换：在机器学习和数据分析中，矩阵乘法用于将数据变换为新的表示形式，常用于神经网络中的前向传播和反向传播。
3. 系统方程：在控制系统和物理系统中，矩阵乘法用于描述和解决系统方程。

什么时候使用点乘，什么时候使用矩阵乘法？

• 点乘：
  • 当你需要计算两个向量之间的相似度或投影时，使用点乘。
  • 在机器学习中，点乘常用于特征向量之间的相似度计算，如余弦相似度。
• 矩阵乘法：
  • 当你需要将一个线性变换应用到数据上时，使用矩阵乘法。
  • 在神经网络中，矩阵乘法用于前向传播过程中的权重矩阵和输入向量的乘积。
  • 在数据处理中，矩阵乘法用于将数据投影到新的维度或进行维度变换。

举例说明

1. 点乘： 如果 (\mathbf{a} = [1, 2, 3]) 和 (\mathbf{b} = [4, 5, 6])，它们的点乘是： [ \mathbf{a} \cdot \mathbf{b} = 1 \cdot 4 + 2 \cdot 5 + 3 \cdot 6 = 4 + 10 + 18 = 32 ]

2. 矩阵乘法： 如果 (\mathbf{A} = \begin{bmatrix} 1 & 2 \ 3 & 4 \end{bmatrix}) 和 (\mathbf{B} = \begin{bmatrix} 5 & 6 \ 7 & 8 \end{bmatrix})，它们的矩阵乘法是： [ \mathbf{A} \cdot \mathbf{B} = \begin{bmatrix} 1 \cdot 5 + 2 \cdot 7 & 1 \cdot 6 + 2 \cdot 8 \ 3 \cdot 5 + 4 \cdot 7 & 3 \cdot 6 + 4 \cdot 8 \end{bmatrix} = \begin{bmatrix} 19 & 22 \ 43 & 50 \end{bmatrix} ]

通过这些解释和示例，你应该可以更好地理解点乘和矩阵乘法的不同用途及其在实际应用中的选择依据。

#dot_product #matrix_product

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Vector 和scaler 就是矢量和标量 Vector是有方向 有长短的 Scalar是没有方向，只有长短的 Vector的运算其实很简单，就是x 对应x的，y对应y的 

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Matrix equations in NN link(https://www.youtube.com/watch?v=ZTt9gsGcdDo&t=357s)

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Transformer Neural Network（attention mechanisim） Query /key/value是来自 检索系统 retrieval system

下面的图是怎么进行检索我们想要的word： 也就是query和key的dot product（他们都是向量vector）会生成新的score矩阵（matrix）  现在这个matrix就是可以决定哪个字和哪个字最相关的。 （想想为什么刚好是这种形状，embedding的时候，每个word的dimention似乎消失了，因为抵消了）  现在是用value matrix去除the square root of dimension and keys去scale ，这样做的目的是为了获得更加稳定的gradient（因为两个vector相乘，会有exploding的effects）  接下里就是要获取概率，就用的softmax来对scale后的函数进行求概率值的matrix。 从0-1。 Value越高，model就越confident，之前的哪个word 要attend to。 （注意到 attention）  然后就可以用这个概率函数乘现在的value vector，从而获取output。  R然后就是把这个output feed进去一个linear layer 去process  multi headead attention的意思，就是要把每个word的query ， key， value 分开。 每个word 都是一个attention head， 然后我们是要concate他们的。 

link（https://www.youtube.com/watch?v=4Bdc55j80l8&t=93s）

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-07-25-为什么weight不够描述，还要加入bias。 感觉back propogation的过程，偏导数很复杂…

2024-07-25-为什么weight不够描述，还要加入bias。 感觉back propogation的过程，偏导数很复杂。 你能2简单一点吗？

---

layout: post title: ‘为什么weight不够描述，还要加入bias。 感觉back propogation的过程，偏导数很复杂。 你能2简单一点吗？’ date: 2024-07-25T16:33:49-04:00

---

好的，让我们一步一步地简化并解释为什么需要偏置（bias）以及反向传播（backpropagation）中的偏导数计算。

为什么需要偏置

1. 激活值偏移：
   • 线性变换：如果没有偏置项，所有的输入经过线性变换（即权重矩阵乘以输入向量）后，输出总是会经过原点（即输入为零时，输出也为零）。
   • 引入偏移：偏置项允许模型在输入为零时输出一个非零值。这就相当于给激活函数的输入加了一个偏移量，使模型能够更灵活地拟合数据。
2. 提升表达能力：
   • 灵活性：偏置项提供了额外的自由度，使得神经元在拟合复杂数据时更有灵活性。
   • 效果更好：在没有偏置项的情况下，模型可能需要更多的层和神经元才能达到相同的效果。

偏置的简单例子

假设我们有一个简单的神经元，其输入为 (x)，权重为 (w)，偏置为 (b)，输出为 (y)。

• 没有偏置：( y = w \cdot x )
• 有偏置：( y = w \cdot x + b )

偏置项 (b) 允许模型更好地拟合数据。例如，如果所有输入 (x) 都是零，而我们希望输出为某个非零值，那么偏置项就非常有用。

反向传播的简单解释

反向传播的核心思想是通过计算损失函数相对于每个参数的梯度，然后使用这些梯度来更新参数，使损失函数逐渐减小。

反向传播的步骤

1. 前向传播：
   • 计算每层的激活值，直到得到最终输出。
2. 计算损失：
   • 根据预测输出和真实值计算损失函数的值。
3. 反向传播：
   • 从输出层开始，逐层向前计算每个参数的梯度（偏导数）。

简化的反向传播示例

假设我们有一个简单的两层神经网络：输入层（输入为 (x)），隐藏层（权重为 (W_1)，偏置为 (b_1)），输出层（权重为 (W_2)，偏置为 (b_2)）。使用均方误差作为损失函数。

1. 前向传播：

   • 隐藏层： [ z_1 = W_1 \cdot x + b_1 ] [ a_1 = \sigma(z_1) ]
   • 输出层： [ z_2 = W_2 \cdot a_1 + b_2 ] [ a_2 = \sigma(z_2) ]

2. 计算损失： [ L = \frac{1}{2} (a_2 - y)^2 ]

3. 反向传播：

   • 输出层的梯度： [ \delta_2 = (a_2 - y) \cdot \sigma’(z_2) ]
     • 权重 (W_2) 的梯度： [ \frac{\partial L}{\partial W_2} = \delta_2 \cdot a_1^T ]
     • 偏置 (b_2) 的梯度： [ \frac{\partial L}{\partial b_2} = \delta_2 ]
   • 隐藏层的梯度： [ \delta_1 = (W_2^T \cdot \delta_2) \cdot \sigma’(z_1) ]
     • 权重 (W_1) 的梯度： [ \frac{\partial L}{\partial W_1} = \delta_1 \cdot x^T ]
     • 偏置 (b_1) 的梯度： [ \frac{\partial L}{\partial b_1} = \delta_1 ]

总结

• 偏置项的作用：
  • 提供额外的自由度，使模型能够更灵活地拟合数据。
  • 允许模型在输入为零时输出非零值，提高表达能力。
• 反向传播的步骤：
  • 前向传播计算输出。
  • 计算损失。
  • 反向传播计算每层的梯度。
• 反向传播的简单示例：
  • 通过链式法则计算每层的梯度。
  • 使用这些梯度更新权重和偏置。

以下是一个简单的 Python 代码示例，展示如何进行前向传播和反向传播：

import numpy as np

# 激活函数及其导数
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def sigmoid_derivative(x):
    return sigmoid(x) * (1 - sigmoid(x))

# 输入数据和目标输出
x = np.array([[0.1], [0.2], [0.3]])  # 3x1 输入向量
y = np.array([[0.5]])  # 1x1 输出向量

# 初始化权重和偏置
W1 = np.random.randn(3, 2)  # 3x2 权重矩阵（输入到隐藏层）
b1 = np.random.randn(2)     # 2x1 偏置向量（隐藏层）
W2 = np.random.randn(2, 1)  # 2x1 权重矩阵（隐藏层到输出层）
b2 = np.random.randn(1)     # 1x1 偏置向量（输出层）

# 前向传播
z1 = np.dot(x.T, W1) + b1  # 计算隐藏层的线性组合
a1 = sigmoid(z1)           # 隐藏层的激活值
z2 = np.dot(a1, W2) + b2   # 计算输出层的线性组合
a2 = sigmoid(z2)           # 输出层的激活值

# 计算损失
loss = 0.5 * np.mean((a2 - y) ** 2)

# 反向传播
delta2 = (a2 - y) * sigmoid_derivative(z2)
dW2 = np.dot(a1.T, delta2)
db2 = np.sum(delta2, axis=0)

delta1 = np.dot(delta2, W2.T) * sigmoid_derivative(z1)
dW1 = np.dot(x, delta1)
db1 = np.sum(delta1, axis=0)

# 更新权重和偏置
learning_rate = 0.1
W2 -= learning_rate * dW2
b2 -= learning_rate * db2
W1 -= learning_rate * dW1
b1 -= learning_rate * db1

print(f'Loss: {loss}')

通过这些步骤，我们可以更好地理解神经网络中偏置项的作用以及反向传播的基本原理。如果你有其他问题或需要进一步解释，请告诉我！

#bias #backpropogation #calculus

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

激活函数的作用（NN里面） 先行变成非线性， 提高模型的表达能力

激活函数的作用

激活函数的主要作用是引入非线性，使得神经网络能够逼近任何非线性函数。常见的激活函数包括：

•	Sigmoid：

\sigma(z) = \frac{1}{1 + e^{-z}}

输出范围为 (0, 1) 。 • Tanh：

\sigma(z) = \tanh(z) = \frac{e^z - e^{-z}}{e^z + e^{-z}}

输出范围为 (-1, 1) 。 • ReLU（Rectified Linear Unit）：

\sigma(z) = \max(0, z)

输出范围为 [0, \infty) 。

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-07-25-NN里面说的每个neuron的activation是怎么回事呢？ activation减去y是cost？ 为什么…

2024-07-25-NN里面说的每个neuron的activation是怎么回事呢？ activation减去y是cost？ 为什么activation是weights+ activation+bias？

---

layout: post title: ‘NN里面说的每个neuron的activation是怎么回事呢？ activation减去y是cost？ 为什么activation是weights+ activation+bias？’ date: 2024-07-25T16:13:37-04:00

---

在神经网络（Neural Network，NN）中，每个神经元（Neuron）的激活函数（Activation Function）是其核心组件之一。激活函数的作用是引入非线性，使得神经网络能够处理复杂的函数映射。

神经元的激活和前向传播

在神经网络中，每个神经元的激活值是通过以下步骤计算的：

1. 线性组合：
   • 输入向量与权重向量进行线性组合，并加上偏置。
   • 公式为： [ z = W \cdot x + b ] 其中，( W ) 是权重向量，( x ) 是输入向量，( b ) 是偏置，( z ) 是线性组合的结果。
2. 激活函数：
   • 将线性组合的结果 ( z ) 通过激活函数 ( \sigma )，得到神经元的激活值 ( a )。
   • 公式为： [ a = \sigma(z) ]

激活函数的作用

激活函数的主要作用是引入非线性，使得神经网络能够逼近任何非线性函数。常见的激活函数包括：

• Sigmoid： [ \sigma(z) = \frac{1}{1 + e^{-z}} ] 输出范围为 ( (0, 1) )。

• Tanh： [ \sigma(z) = \tanh(z) = \frac{e^z - e^{-z}}{e^z + e^{-z}} ] 输出范围为 ( (-1, 1) )。

• ReLU（Rectified Linear Unit）： [ \sigma(z) = \max(0, z) ] 输出范围为 ( [0, \infty) )。

激活值与损失函数

在神经网络的输出层，激活值通常与目标值 ( y ) 进行比较，用于计算损失（Loss），以衡量模型预测的准确性。

• 损失函数：损失函数是用来衡量模型预测值与真实值之间差异的函数。常见的损失函数包括均方误差（MSE）、交叉熵损失等。

  • 均方误差（MSE）： [ L = \frac{1}{2} (a - y)^2 ] 其中，( a ) 是预测值，( y ) 是真实值。

  • 交叉熵损失（Cross-Entropy Loss）： [ L = - (y \log(a) + (1 - y) \log(1 - a)) ]

为什么是权重加激活再加偏置

1. 线性组合：输入向量与权重向量的线性组合 ( W \cdot x ) 表示每个输入对输出的影响。
2. 偏置：偏置 ( b ) 用于调整输出，允许模型更好地拟合数据，即使在输入为零的情况下也可以有非零的输出。
3. 激活函数：激活函数 ( \sigma ) 应用于线性组合的结果，使得输出引入非线性，从而提高模型的表达能力。

前向传播的完整过程

1. 输入层：接收输入数据。
2. 隐藏层：
   • 对每个神经元，计算线性组合 ( z^{[l]} = W^{[l]} \cdot a^{[l-1]} + b^{[l]} )。
   • 应用激活函数 ( a^{[l]} = \sigma(z^{[l]}) )。
3. 输出层：
   • 对每个神经元，计算线性组合 ( z^{[L]} = W^{[L]} \cdot a^{[L-1]} + b^{[L]} )。
   • 应用激活函数 ( a^{[L]} = \sigma(z^{[L]}) )，得到预测输出。
4. 计算损失：根据预测输出和真实标签，计算损失 ( L )。

示例代码

以下是使用 Python 和 NumPy 实现一个简单的前向传播过程的示例代码：

import numpy as np

# 定义激活函数和其导数
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

# 初始化参数
np.random.seed(0)
X = np.array([[0, 1], [1, 0], [1, 1], [0, 0]])  # 输入数据
y = np.array([[1], [1], [0], [0]])  # 目标输出

W1 = np.random.randn(2, 2)  # 输入层到隐藏层的权重
b1 = np.random.randn(2)     # 隐藏层的偏置
W2 = np.random.randn(2, 1)  # 隐藏层到输出层的权重
b2 = np.random.randn(1)     # 输出层的偏置

# 前向传播
z1 = np.dot(X, W1) + b1
a1 = sigmoid(z1)
z2 = np.dot(a1, W2) + b2
a2 = sigmoid(z2)

# 计算损失
loss = np.mean((a2 - y) ** 2)
print(f'Loss: {loss}')

总结

• 激活值：每个神经元的激活值是通过将输入与权重线性组合后加上偏置，再通过激活函数计算得出的。
• 损失函数：用于衡量模型预测值与真实值之间的差异。
• 前向传播：包括计算线性组合、应用激活函数和计算损失。

通过理解这些概念，你可以更好地掌握神经网络的工作原理。如果你有其他问题或需要进一步解释，请告诉我！

#activate_function #ReLU #Sigmoid #NN #tanh #loss_function #backpropogation #forwardproporgation

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-07-25-chain rule在NN的作用， back propagation跟chain rule有什么关系

---

layout: post title: ‘chain rule在NN的作用， back propagation跟chain rule有什么关系 ‘ date: 2024-07-25T16:08:05-04:00

---

链式法则（Chain Rule）在神经网络中的作用至关重要，特别是在反向传播（Backpropagation）过程中，用于计算损失函数相对于每个权重的梯度。链式法则允许我们将复杂函数的导数分解成更简单的部分，从而计算出最终的梯度。

链式法则简介

链式法则是一种用于计算复合函数导数的方法。假设我们有一个复合函数 ( f(g(x)) )，其中 ( f ) 和 ( g ) 都是可微函数，链式法则告诉我们如何计算这个复合函数的导数：

[ \frac{d}{dx} f(g(x)) = f’(g(x)) \cdot g’(x) ]

也就是说，复合函数的导数等于外层函数对内层函数的导数乘以内层函数对自变量的导数。

链式法则在神经网络中的应用

在神经网络中，链式法则被用来计算各层参数的梯度，以便进行参数更新。神经网络中的每一层都可以视为一个函数，通过链式法则，我们可以逐层计算梯度。

反向传播和链式法则

反向传播是通过链式法则计算梯度的一种算法。它从输出层开始，逐层向后计算梯度，直到输入层。以下是反向传播的具体步骤，结合链式法则进行解释：

1. 前向传播（Forward Propagation）

在前向传播中，输入数据通过网络的各层传递，计算出最终的预测输出。每一层的计算可以表示为：

[ a^{[l]} = \sigma(z^{[l]}) ]

其中：

• ( z^{[l]} = W^{[l]} a^{[l-1]} + b^{[l]} ) 是第 ( l ) 层的线性组合。
• ( \sigma ) 是激活函数。
• ( a^{[l-1]} ) 是第 ( l-1 ) 层的激活值。

2. 计算损失（Loss Calculation）

使用损失函数 ( J ) 计算预测输出与真实标签之间的损失：

[ L = J(a^{[L]}, y) ]

其中 ( a^{[L]} ) 是输出层的激活值，( y ) 是真实标签。

3. 反向传播（Backward Propagation）

在反向传播中，从输出层开始，逐层向前计算梯度。利用链式法则，我们可以逐层计算损失函数相对于每个参数的梯度。

输出层梯度计算：

首先计算损失函数相对于输出层激活值的梯度：

[ \frac{\partial L}{\partial a^{[L]}} = \frac{\partial J(a^{[L]}, y)}{\partial a^{[L]}} ]

然后计算损失函数相对于输出层线性组合 ( z^{[L]} ) 的梯度：

[ \delta^{[L]} = \frac{\partial L}{\partial a^{[L]}} \cdot \sigma’(z^{[L]}) ]

隐藏层梯度计算：

对于每一隐藏层 ( l )，梯度计算如下：

[ \delta^{[l]} = (\delta^{[l+1]} W^{[l+1]}) \cdot \sigma’(z^{[l]}) ]

权重和偏置的梯度：

最后，计算每一层权重和偏置的梯度：

[ \frac{\partial L}{\partial W^{[l]}} = a^{[l-1]} \delta^{[l]} ] [ \frac{\partial L}{\partial b^{[l]}} = \delta^{[l]} ]

示例代码

以下是使用链式法则和反向传播计算梯度的简化示例代码（使用 Python 和 NumPy）：

import numpy as np

# 定义激活函数和其导数
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def sigmoid_derivative(x):
    return sigmoid(x) * (1 - sigmoid(x))

# 初始化参数
np.random.seed(0)
X = np.array([[0, 1], [1, 0], [1, 1], [0, 0]])  # 输入数据
y = np.array([[1], [1], [0], [0]])  # 目标输出

W1 = np.random.randn(2, 2)  # 输入层到隐藏层的权重
b1 = np.random.randn(2)     # 隐藏层的偏置
W2 = np.random.randn(2, 1)  # 隐藏层到输出层的权重
b2 = np.random.randn(1)     # 输出层的偏置

# 前向传播
z1 = np.dot(X, W1) + b1
a1 = sigmoid(z1)
z2 = np.dot(a1, W2) + b2
a2 = sigmoid(z2)

# 计算损失
loss = np.mean((a2 - y) ** 2)

# 反向传播
delta2 = (a2 - y) * sigmoid_derivative(z2)
dW2 = np.dot(a1.T, delta2)
db2 = np.sum(delta2, axis=0)

delta1 = np.dot(delta2, W2.T) * sigmoid_derivative(z1)
dW1 = np.dot(X.T, delta1)
db1 = np.sum(delta1, axis=0)

# 更新权重和偏置
learning_rate = 0.1
W2 -= learning_rate * dW2
b2 -= learning_rate * db2
W1 -= learning_rate * dW1
b1 -= learning_rate * db1

print(f'Loss: {loss}')

总结

• 链式法则（Chain Rule）：用于计算复合函数的导数，通过逐层分解计算每一层的导数。
• 反向传播（Backpropagation）：利用链式法则从输出层开始逐层计算梯度，并更新神经网络的参数。
• 梯度更新：使用梯度下降算法，根据计算出的梯度更新权重和偏置。

链式法则在神经网络训练中的作用至关重要，通过逐层计算梯度，反向传播算法能够有效地优化神经网络的参数，提高模型的性能。如果你有其他问题或需要进一步解释，请告诉我！

#chain_rule #NN #back_propogation #forward_propogation

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Chain rule 在NN的作用

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

backpropogation 和forward propogation back propagation 就是通过正确的label（ground truth）反向去找出每一层layer的neuron的weights 和biases需要让最后的结果最小，他们的weights和bias的value。

每一个训练的图片/data ，都需要经历这个过程，因为他们每一个都有自己正确的label。 我们训练就是要加载所有的data，找出平均值（cost function最小的，dataset里面的所有数据都要满足的）最小的组合

因为整个数据库太大了，计算压力很大，所以人们采用minibacth；来做一个小的模仿。试图用这一个小的set来对整个dataset的weights 和bias进行估计。

Stochastic gradient descent 就是一个醉汉，要以最快的速度，走最陡的坡，下山，也就是找到local minimal

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

gradient descent 是什么 找出那一个weights 和biases 能够让cost function最小

Gradient descent 其实是一个我们自己制造的过程，也就是去爬坡，寻找最快到达坡底的过程。 我们一直不停的比较我们的cost function和实际的输出之间的平方差，然后不停的找出weight和bias的组合，让这个过程最小，就叫做梯度下降。

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

What is RNN?

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

NN 的结构， weights 和biases的解释 

NN的目的就是去找minimum of certain function  weights： neuron和neuron之间的联系是否紧密 biases：neuron是active还是inactive

怎么训练让NN聪明起来呢： 我们自己定义Cost function： 下一步就是add up （trash ouput activation - 我们期待的value（也就是label/ground truth））的平方 = the cost of single training example 怎么判断NN学习的好不好： Cost 越小，差异越小，证明学的越好 Cost 越大， 差异越大，学习的就越差

当我们有成千上万的训练数据： average all cost/ 训练数量 就可以了

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Sigmoid & Relu in NN

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Context vector in Encoder and Decoder Encode: 这里说的encode是说要encode context vector Cell state + hidden state from all layer of LSTM cells in Encoder = Contect Vector

Decode：这里说的encode是说要decode context vector

模型的架构： encoder和decoder的网络都包含embedding layer， LSTM layer 和fully conncted layer

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-07-25-encoder decoder LSTM是supervised 还是unsupervised ，你知道训练…

2024-07-25-encoder decoder LSTM是supervised 还是unsupervised ，你知道训练过程和valida 和test 过程的具体操作吗

---

layout: post title: ‘encoder decoder LSTM是supervised 还是unsupervised ，你知道训练过程和valida 和test 过程的具体操作吗 ‘ date: 2024-07-25T09:33:57-04:00

---

Encoder-Decoder LSTM 是一种典型的有监督学习（supervised learning）方法，通常用于处理序列到序列（sequence-to-sequence）的任务，例如机器翻译、文本摘要、语音识别等。在这些任务中，模型通过输入-输出对（input-output pairs）进行训练，其中输入和输出都是序列。

训练过程

在训练过程中，模型学习从输入序列到输出序列的映射。以下是训练过程的具体步骤：

1. 数据准备：
   • 准备输入序列和对应的目标输出序列。
   • 将输入和输出序列转化为数字化表示（如单词的索引或字符的索引）。
2. 模型初始化：
   • 初始化 Encoder 和 Decoder 网络，通常包括嵌入层（Embedding Layer）、LSTM 层和全连接层（Fully Connected Layer）。
3. 前向传播（Forward Pass）：
   • Encoder：输入序列通过 Encoder，生成上下文向量（Context Vector）和隐藏状态（Hidden State）。

     encoder_output, (hidden, cell) = encoder(input_seq)
     

   • Decoder：Decoder 使用 Encoder 的输出和隐藏状态，逐步生成输出序列。

     decoder_output, (hidden, cell) = decoder(target_seq, (hidden, cell))
     

4. 计算损失（Loss Calculation）：
   • 计算 Decoder 输出与实际目标序列之间的损失，通常使用交叉熵损失（Cross-Entropy Loss）。

     loss = loss_function(decoder_output, target_seq)
     

5. 反向传播（Backward Pass）和参数更新：
   • 通过反向传播计算梯度，并使用优化器更新模型参数。

     loss.backward()
     optimizer.step()
     

验证过程（Validation）

验证过程用于评估模型在未见过的验证数据上的性能，防止过拟合。具体步骤如下：

1. 禁用梯度计算：
   • 在验证过程中，不需要计算梯度，因此禁用梯度计算以节省内存和计算资源。

     with torch.no_grad():
     

2. 前向传播：
   • 使用验证集输入通过 Encoder 和 Decoder 进行前向传播。

     encoder_output, (hidden, cell) = encoder(validation_input_seq)
     decoder_output, (hidden, cell) = decoder(validation_target_seq, (hidden, cell))
     

3. 计算验证损失：
   • 计算验证损失，以评估模型在验证集上的表现。

     validation_loss = loss_function(decoder_output, validation_target_seq)
     

测试过程（Testing）

测试过程用于评估模型在完全未见过的数据上的性能。测试过程与验证过程类似，但使用的是测试数据集。

1. 禁用梯度计算：
   • 与验证过程相同，禁用梯度计算。

     with torch.no_grad():
     

2. 前向传播：
   • 使用测试集输入通过 Encoder 和 Decoder 进行前向传播。

     encoder_output, (hidden, cell) = encoder(test_input_seq)
     decoder_output, (hidden, cell) = decoder(test_target_seq, (hidden, cell))
     

3. 计算测试损失和评估指标：
   • 计算测试损失和其他评估指标（如准确率、BLEU 分数等），以评估模型在测试集上的表现。

     test_loss = loss_function(decoder_output, test_target_seq)
     # 其他评估指标
     

示例代码

以下是一个简化的 Encoder-Decoder LSTM 训练、验证和测试过程的代码示例（使用 PyTorch）：

import torch
import torch.nn as nn
import torch.optim as optim

# 超参数
vocab_size = 1000
embedding_dim = 256
hidden_dim = 512
output_dim = vocab_size
num_epochs = 10

# Encoder 模型
class Encoder(nn.Module):
    def __init__(self, vocab_size, embedding_dim, hidden_dim):
        super(Encoder, self).__init__()
        self.embedding = nn.Embedding(vocab_size, embedding_dim)
        self.lstm = nn.LSTM(embedding_dim, hidden_dim, batch_first=True)

    def forward(self, x):
        x = self.embedding(x)
        output, (hidden, cell) = self.lstm(x)
        return output, (hidden, cell)

# Decoder 模型
class Decoder(nn.Module):
    def __init__(self, vocab_size, embedding_dim, hidden_dim, output_dim):
        super(Decoder, self).__init__()
        self.embedding = nn.Embedding(vocab_size, embedding_dim)
        self.lstm = nn.LSTM(embedding_dim, hidden_dim, batch_first=True)
        self.fc = nn.Linear(hidden_dim, output_dim)

    def forward(self, x, hidden):
        x = self.embedding(x)
        output, hidden = self.lstm(x, hidden)
        output = self.fc(output)
        return output, hidden

# 初始化模型
encoder = Encoder(vocab_size, embedding_dim, hidden_dim)
decoder = Decoder(vocab_size, embedding_dim, hidden_dim, output_dim)

# 损失函数和优化器
criterion = nn.CrossEntropyLoss()
encoder_optimizer = optim.Adam(encoder.parameters(), lr=0.001)
decoder_optimizer = optim.Adam(decoder.parameters(), lr=0.001)

# 训练过程
for epoch in range(num_epochs):
    encoder.train()
    decoder.train()

    # 假设 input_seq 和 target_seq 是预处理好的训练数据
    encoder_output, hidden = encoder(input_seq)
    decoder_output, _ = decoder(target_seq, hidden)
    
    loss = criterion(decoder_output.view(-1, vocab_size), target_seq.view(-1))
    loss.backward()
    encoder_optimizer.step()
    decoder_optimizer.step()

    print(f'Epoch {epoch+1}, Loss: {loss.item()}')

# 验证过程
encoder.eval()
decoder.eval()
with torch.no_grad():
    encoder_output, hidden = encoder(validation_input_seq)
    decoder_output, _ = decoder(validation_target_seq, hidden)
    validation_loss = criterion(decoder_output.view(-1, vocab_size), validation_target_seq.view(-1))
    print(f'Validation Loss: {validation_loss.item()}')

# 测试过程
encoder.eval()
decoder.eval()
with torch.no_grad():
    encoder_output, hidden = encoder(test_input_seq)
    decoder_output, _ = decoder(test_target_seq, hidden)
    test_loss = criterion(decoder_output.view(-1, vocab_size), test_target_seq.view(-1))
    print(f'Test Loss: {test_loss.item()}')

总结

• 有监督学习：Encoder-Decoder LSTM 是一种有监督学习方法，通过输入-输出对进行训练。
• 训练过程：包括数据准备、模型初始化、前向传播、损失计算和反向传播。
• 验证和测试过程：用于评估模型在未见过数据上的表现，防止过拟合和评估模型的泛化能力。

希望这些解释和示例能帮助你更好地理解 Encoder-Decoder LSTM 的实现和训练过程。如果你有其他问题或需要进一步解释，请告诉我！

#encoder #decoder #lstm #supervised_learning #training #testing #validation

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Long short term memory = cell + hidden states long term =cell Short term : hidden states

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-07-25-embedding的维度 你是怎么确定的 呢？ 刚刚你说维度是 4 ，是随便乱说的吗？ 刚刚3个word…

2024-07-25-embedding的维度 你是怎么确定的 呢？ 刚刚你说维度是 4 ，是随便乱说的吗？ 刚刚3个word，也就是说encoding的维度是3？ embedding的维度跟word的多少有关系吗

---

layout: post title: ‘embedding的维度 你是怎么确定的 呢？ 刚刚你说维度是 4 ，是随便乱说的吗？ 刚刚3个word，也就是说encoding的维度是3？ embedding的维度跟word的多少有关系吗 ‘ date: 2024-07-25T09:24:05-04:00

---

嵌入层的维度（embedding dimension）是一个超参数，它决定了每个单词将被表示为多长的向量。嵌入维度的选择并不是随意的，而是基于以下几个因素来决定的：

嵌入维度的选择

1. 词汇表大小（Vocabulary Size）：
   • 嵌入维度不等于词汇表大小。词汇表大小表示有多少个不同的单词或标记，而嵌入维度表示每个单词被表示为多长的向量。
   • 词汇表大小与嵌入维度之间没有直接的数学关系，但较大的词汇表通常需要较大的嵌入维度来捕捉丰富的语义信息。
2. 任务的复杂性：
   • 对于复杂的任务，如自然语言处理中的机器翻译或情感分析，通常需要较大的嵌入维度来捕捉丰富的语义和上下文信息。
   • 对于简单的任务，如简单的文本分类或关键词检索，较小的嵌入维度可能就足够了。
3. 训练数据量：
   • 如果你的训练数据量很大，你可以选择较大的嵌入维度，因为有足够的数据来学习丰富的表示。
   • 如果你的训练数据量较小，选择较大的嵌入维度可能会导致过拟合。
4. 计算资源：
   • 较大的嵌入维度会增加模型的参数数量，从而增加计算和存储需求。需要平衡嵌入维度和计算资源。

常见的嵌入维度

在实际应用中，常见的嵌入维度通常在 50 到 300 之间。例如：

• 小型任务或词汇表：嵌入维度可以选择 50 到 100。
• 中型任务或词汇表：嵌入维度可以选择 100 到 200。
• 大型任务或词汇表：嵌入维度可以选择 200 到 300 或更大。

示例代码

假设我们有一个简单的例子，其中词汇表大小为 3，嵌入维度为 4。这里的嵌入维度选择是为了示范，实际应用中可以根据上述因素进行调整。

import torch
import torch.nn as nn

# 超参数
vocab_size = 3    # 词汇表大小
embedding_dim = 4 # 嵌入维度
hidden_dim = 5    # LSTM 隐藏单元数
output_dim = 1    # 输出维度

# 示例输入序列（词汇表索引）
input_seq = torch.tensor([[0, 1], [1, 2]], dtype=torch.long)

# 嵌入层和 LSTM
class LSTMModel(nn.Module):
    def __init__(self, vocab_size, embedding_dim, hidden_dim, output_dim):
        super(LSTMModel, self).__init__()
        self.embedding = nn.Embedding(vocab_size, embedding_dim)
        self.lstm = nn.LSTM(embedding_dim, hidden_dim, batch_first=True)
        self.fc = nn.Linear(hidden_dim, output_dim)

    def forward(self, x):
        x = self.embedding(x)  # 应用嵌入层
        out, _ = self.lstm(x)  # LSTM
        out = self.fc(out[:, -1, :])  # 全连接层
        return out

# 初始化模型
model = LSTMModel(vocab_size, embedding_dim, hidden_dim, output_dim)

# 前向传播
output = model(input_seq)
print(output)

总结

• 词汇表大小与嵌入维度无直接关系。词汇表大小表示词汇的数量，而嵌入维度表示每个词汇的向量表示的长度。
• 嵌入维度的选择基于任务复杂性、训练数据量和计算资源等因素。
• 实际应用中常见的嵌入维度范围是 50 到 300，根据具体任务和数据量进行调整。

通过这些原则和示例，你可以更好地选择合适的嵌入维度，以提高模型的性能和效率。如果你有其他问题或需要进一步解释，请告诉我！

#embedding #lstm

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

LSTM的各种state和gate ⁃ Gates： gates决定了哪些信息需要保留，那些信息需要通过（在训练阶段） sigmoid function就是用来做这个工作的，因为0-1可以帮助我们筛选是保留（1）还是丢掉（0）（通过乘以sigmoid的方式，00是0， 11=1 这种方式来决定保留还是舍弃）  Forget gate：第一个门就是这个门，决定忘记还是保留哪些信息（sigmoid）（previous cell state） input gate：tanh * sigmoid来对forget gate output出来的信息机型计算， 来计算出new cell state（可以叫做input gate output）（sigmoid * tanh） output gate：接受从input gate 传递过来的信息，用的是tanh和sigmoid 来规范，(tanh * sigmoid) 注意这些gate之间传递的信息，就是hidden state， output gate 传递给下一个LSTM cell（包含所有完整的gate）的信息，也是通过hiddent state来传递的。

⁃	也就是说这一系列的计算和传递信息，我们就是需要更新cell state和hiddent state！  这是用代码做的LSTM from scratch 

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Sigmoid 和tanh 的区别 Sigmoid： 可以把问题转化成0-1的之间，（比如概率问题）  tanh： 因为explosion的问题，tanh可以让value保持在-1到1之间 

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Sigmoid activation 

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-07-24-我不理解为什么需要遗忘长时间记忆，LSTM 你刚刚说的 你能解释吗

---

layout: post title: ‘我不理解为什么需要遗忘长时间记忆，LSTM 你刚刚说的 你能解释吗’ date: 2024-07-24T09:42:40-04:00

---

在 LSTM（长短期记忆网络）中，遗忘门（Forget Gate）的作用是控制记忆单元中哪些信息需要保留，哪些需要丢弃。这个机制非常关键，因为它解决了普通 RNN（循环神经网络）在处理长序列数据时面临的两个主要问题：梯度消失和梯度爆炸。

为什么需要遗忘长时间记忆？

1. 避免信息过载：
   • 在处理长序列数据时，网络中会累积大量信息。如果所有信息都被保留，记忆单元可能会被无关或不重要的信息填满，导致重要的信息被淹没。遗忘门允许网络选择性地丢弃一些不再重要的旧信息，从而腾出空间存储新的有用信息。
2. 保持网络的敏捷性：
   • 如果网络保留了所有过去的信息，它可能会变得迟钝，对新输入的反应不够敏捷。通过遗忘门，LSTM 可以动态调整其记忆内容，确保对当前输入做出快速而准确的响应。
3. 防止梯度消失和爆炸：
   • 在长序列训练中，梯度消失和梯度爆炸是常见的问题。遗忘门可以帮助调节梯度流动，防止梯度在长时间步中变得过小或过大，确保网络在训练中保持稳定。

LSTM 中遗忘门的工作原理

遗忘门的作用是决定前一时间步的记忆有多少需要被保留。它通过一个 sigmoid 激活函数将输入和前一时间步的隐藏状态进行计算，输出一个介于 0 和 1 之间的值。这个值用来对当前的记忆单元进行调节。

具体计算过程：

1. 遗忘门计算： [ f_t = \sigma(W_f \cdot [h_{t-1}, x_t] + b_f) ]
   • 其中，( \sigma ) 是 sigmoid 函数， ( W_f ) 是遗忘门的权重矩阵， ( h_{t-1} ) 是前一时间步的隐藏状态， ( x_t ) 是当前时间步的输入， ( b_f ) 是偏置项。
2. 记忆单元更新：
   • 记忆单元的更新包括两部分：前一时间步的记忆经过遗忘门调节后保留下来的部分，以及当前时间步的新信息经过输入门调节后添加的部分。 [ C_t = f_t \cdot C_{t-1} + i_t \cdot \tilde{C}_t ]
   • 其中，( C_{t-1} ) 是前一时间步的记忆单元状态，( i_t ) 是输入门的输出， ( \tilde{C}_t ) 是当前时间步的新记忆候选值。

例子解释

假设我们有一个句子，“The weather today is sunny and bright”，现在我们在处理这个序列。对于每个单词，LSTM 会决定哪些信息需要保留，哪些信息可以遗忘。例如：

• 当处理“today”时，LSTM 可能会记住“weather”是与天气有关的信息。
• 当处理到“sunny”时，LSTM 可能会遗忘掉一些关于“weather”的具体细节，而更加关注“sunny”这个新信息。
• 当处理到“bright”时，LSTM 会结合之前的信息进行综合判断，可能会遗忘更多关于“weather”的信息而更专注于当前描述的天气状况。

这种选择性遗忘和记忆的过程使得 LSTM 能够在处理长序列时保持有效性和准确性。

总结

LSTM 通过遗忘门来动态调节记忆单元中的信息，从而解决了普通 RNN 在长序列数据处理中面临的梯度消失和梯度爆炸问题。遗忘门允许网络选择性地丢弃不再重要的旧信息，保持对当前输入的敏捷反应和网络的稳定性。通过这种机制，LSTM 能够有效地处理长时间步的依赖关系，并在各类序列任务中表现出色。

如果你还有其他问题或需要进一步解释，请告诉我！

#lstm #forget

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-07-24-LSTM 到底是会忘记长期还是短期记忆？

---

layout: post title: ‘LSTM 到底是会忘记长期还是短期记忆？’ date: 2024-07-24T09:39:32-04:00

---

LSTM（长短期记忆网络）设计的初衷是解决标准 RNN（循环神经网络）在处理长期依赖关系时的困难问题。具体来说，LSTM 通过引入门控机制来有效地处理长时间步长的依赖关系。让我们详细讨论一下 LSTM 是如何处理长期和短期记忆的。

LSTM 的基本结构

LSTM 单元包含以下几个关键组件：

1. 输入门（Input Gate）：控制输入信息进入记忆单元的量。
2. 遗忘门（Forget Gate）：控制记忆单元中的信息需要遗忘的量。
3. 输出门（Output Gate）：控制记忆单元中的信息传递到下一层的量。
4. 记忆单元（Cell State）：长时间存储信息，通过直接的通道进行传递，受到门控机制的调控。

LSTM 如何处理记忆

短期记忆

短期记忆在 LSTM 中主要由隐藏状态（Hidden State）维护。隐藏状态每一步都会更新，并传递到下一时间步。这允许 LSTM 捕捉和传递近期的动态信息。

长期记忆

长期记忆在 LSTM 中由记忆单元（Cell State）维护。记忆单元通过直接的通道跨时间步传递信息，受到遗忘门和输入门的调控：

• 遗忘门（Forget Gate）：决定遗忘多少前一时间步的记忆。 [ f_t = \sigma(W_f \cdot [h_{t-1}, x_t] + b_f) ]

• 输入门（Input Gate）：决定多少新的输入信息需要加入到记忆单元中。 [ i_t = \sigma(W_i \cdot [h_{t-1}, x_t] + b_i) ] [ \tilde{C}t = \tanh(W_C \cdot [h{t-1}, x_t] + b_C) ]

• 记忆单元状态更新： [ C_t = f_t \cdot C_{t-1} + i_t \cdot \tilde{C}_t ]

通过门控机制来控制记忆

LSTM 的关键在于其门控机制，允许网络选择性地遗忘或记住信息：

• 遗忘门：控制前一时间步的记忆有多少被保留下来。如果遗忘门的输出接近于 0，表示遗忘前一时间步的大部分信息；如果输出接近于 1，表示保留前一时间步的大部分信息。
• 输入门：控制当前时间步的新信息有多少被加入到记忆单元中。
• 输出门：控制记忆单元中的信息有多少被输出作为当前时间步的隐藏状态。

通过这些门控机制，LSTM 能够有效地保持长期依赖信息，同时根据需要引入新的短期信息。这使得 LSTM 在处理长序列时表现出色，而不会像标准 RNN 那样迅速遗忘早期信息。

结论

• 长期记忆：LSTM 设计用于保留长期记忆。记忆单元通过直接的通道传递信息，门控机制控制何时更新和遗忘信息。
• 短期记忆：LSTM 也处理短期记忆，主要由隐藏状态维护，随着每个时间步更新。

因此，LSTM 既可以保留长期记忆，也可以处理短期记忆。这种设计使其在处理长序列依赖关系时比标准 RNN 更有效。

希望这些解释清晰地展示了 LSTM 如何处理长期和短期记忆。如果你有其他问题或需要进一步详细的解释，请告诉我。

#lstm #forget_gate #input_gate #cell_state

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-07-23-如果我的mac 对我的blog进行了推送到GitHub 更新了。我的raspberry pi上是不是不能…

2024-07-23-如果我的mac 对我的blog进行了推送到GitHub 更新了。我的raspberry pi上是不是不能马上进行更新commit 和push，还需要什么操作吗

---

layout: post title: ‘如果我的mac 对我的blog进行了推送到GitHub 更新了。我的raspberry pi上是不是不能马上进行更新commit 和push，还需要什么操作吗’ date: 2024-07-23T16:56:28-04:00

---

如果你在 Mac 上对博客进行了更新并推送到 GitHub，那么你的 Raspberry Pi 上的本地仓库不会自动更新。你需要在 Raspberry Pi 上执行一些操作来同步这些更改。以下是详细步骤：

在 Raspberry Pi 上同步更新

1. 拉取最新的更改

   首先，你需要在 Raspberry Pi 上拉取最新的更改。打开终端，导航到你的博客仓库目录，然后执行以下命令：

   cd /path/to/your/blog/repo
   git pull origin main
   

   这将从 GitHub 拉取最新的提交并将其合并到你的本地分支中。如果你的默认分支不是 main，请将 main 替换为你的默认分支名称。

2. 解决可能的冲突

   在拉取更改的过程中，如果你在 Raspberry Pi 上也对博客进行了修改，可能会出现合并冲突。在这种情况下，你需要手动解决冲突。Git 会提示你哪些文件存在冲突，并标记冲突部分。解决冲突后，提交更改：

   git add .
   git commit -m "Resolve merge conflicts"
   

3. 推送更改

   如果你在 Raspberry Pi 上做了额外的修改，需要将这些更改推送到 GitHub。首先确保拉取并合并了最新的更改，然后推送：

   git push origin main
   

提示和建议

1. 定期同步：为了避免合并冲突，建议定期在 Raspberry Pi 上拉取最新的更改，特别是在你在 Mac 上频繁更新博客内容的情况下。

2. 分支管理：考虑在不同设备上使用不同的分支进行开发，然后在合并到主分支前进行同步和测试。这可以减少冲突的可能性。

3. 使用 SSH 密钥：如果你没有在 Raspberry Pi 上配置 SSH 密钥，建议配置 SSH 密钥以便更安全和方便地与 GitHub 进行交互。你可以参考 GitHub 的官方文档 来生成和添加 SSH 密钥。

示例完整操作流程

假设你已经在 Mac 上进行了更新并推送到 GitHub，以下是在 Raspberry Pi 上同步这些更改的具体步骤：

1. 导航到博客仓库目录：

   cd /path/to/your/blog/repo
   

2. 拉取最新的更改：

   git pull origin main
   

3. 解决冲突（如果有）：

   打开冲突文件，解决冲突，然后提交：

   git add .
   git commit -m "Resolve merge conflicts"
   

4. 进行本地修改（如果有）：

   进行任何本地修改，然后提交：

   git add .
   git commit -m "Local updates on Raspberry Pi"
   

5. 推送更改：

   git push origin main
   

总结

通过上述步骤，你可以确保 Raspberry Pi 上的博客仓库与 GitHub 上的最新版本同步。如果你有任何问题或需要进一步的帮助，请告诉我。

---

Shortcuts for Next Step:

• input “1” for a detailed guide on setting up SSH keys for GitHub on Raspberry Pi
• input “2” for tips on managing Git branches across multiple devices
• input “3” for troubleshooting common Git issues

Or, you can just type “continue” or “c”, I will continue automatically.

#PI #blog #github #push #commit #pull

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-07-23-embedding

---

layout: post title: ‘embedding’ date: 2024-07-23T16:06:46-04:00

---

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-07-23-tanh的作用和图像

---

layout: post title: ‘tanh的作用和图像’ date: 2024-07-23T16:02:06-04:00

---

Tanh， 把任意输入的从-inifi 到+infinit的value压缩到-1 和+1 之间

#tanh #图像 #三角函数

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Tanh， 把任意输入的从-inifi 到+infinit的value压缩到-1 和+1 之间 

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-07-23-anh 函数在LSTM里面有什么作用吗？ 他和new hidden state, previous hidden…

2024-07-23-anh 函数在LSTM里面有什么作用吗？ 他和new hidden state, previous hidden state concatenation有什么联系吗

---

layout: post title: ‘anh 函数在LSTM里面有什么作用吗？ 他和new hidden state, previous hidden state concatenation有什么联系吗’ date: 2024-07-23T15:56:27-04:00

---

在 LSTM 中，tanh 函数扮演着重要的角色，主要用于控制记忆单元（cell state）和隐藏状态（hidden state）的输出。让我们详细解释 tanh 函数在 LSTM 中的作用及其与新隐藏状态和前一个隐藏状态的关系。

tanh 函数的作用

tanh 函数（双曲正切函数）是一个常见的激活函数，其输出范围为 -1 到 1。它在 LSTM 中的主要作用如下：

1. 标准化输出：tanh 函数将输入值压缩到 -1 到 1 的范围内，有助于稳定网络的训练过程。
2. 引入非线性：通过非线性激活函数，LSTM 可以捕捉更复杂的模式和关系，而不仅仅是线性关系。

LSTM 中的 tanh 使用

在 LSTM 中，tanh 函数主要出现在两个地方：

1. 计算新的细胞状态（cell state）候选值： [ \tilde{C}t = \tanh(W_C \cdot [h{t-1}, x_t] + b_C) ] 这里，tanh 函数用于生成新的候选细胞状态 ( \tilde{C}_t )，其值范围在 -1 到 1 之间，有助于控制更新量。

2. 计算新的隐藏状态（hidden state）： [ h_t = o_t \times \tanh(C_t) ] 这里，tanh 函数应用于更新后的细胞状态 ( C_t )，输出新的隐藏状态 ( h_t )。这样可以确保隐藏状态的值在 -1 到 1 之间，提供稳定的激活信号。

新隐藏状态和前一个隐藏状态的关系

在 LSTM 中，隐藏状态的计算依赖于前一个隐藏状态、当前输入以及各种门控机制的组合。具体来说，隐藏状态的更新步骤如下：

1. 前一个隐藏状态和当前输入的连接： [ [h_{t-1}, x_t] ] 在计算门控值（如输入门、遗忘门、输出门和候选细胞状态）时，前一个隐藏状态 ( h_{t-1} ) 和当前输入 ( x_t ) 通常会被连接起来作为输入。

2. 计算新的候选细胞状态： [ \tilde{C}t = \tanh(W_C \cdot [h{t-1}, x_t] + b_C) ] 这里，tanh 函数用于生成新的候选细胞状态。

3. 更新细胞状态： [ C_t = f_t \times C_{t-1} + i_t \times \tilde{C}t ] 细胞状态结合了前一个细胞状态 ( C{t-1} ) 和新的候选细胞状态 ( \tilde{C}_t )，通过遗忘门 ( f_t ) 和输入门 ( i_t ) 的控制来更新。

4. 计算新的隐藏状态： [ h_t = o_t \times \tanh(C_t) ] 新的隐藏状态通过 tanh 函数应用于更新后的细胞状态 ( C_t )，并通过输出门 ( o_t ) 的控制来产生。

通过这种方式，LSTM 能够利用前一个隐藏状态和当前输入的信息，结合非线性变换（tanh 函数）和门控机制，有效地捕捉序列数据中的长距离依赖关系。

图示化解释

1. 输入序列：x_t 和前一个隐藏状态 h_{t-1} 被连接并输入到各个门（输入门、遗忘门、输出门）。
2. 遗忘门：决定丢弃多少过去的信息。
3. 输入门：决定添加多少新的信息。
4. 候选细胞状态：通过 tanh 函数计算，生成新的候选细胞状态。
5. 细胞状态更新：综合前一个细胞状态和新的候选细胞状态，得到更新的细胞状态。
6. 隐藏状态更新：通过 tanh 函数应用于更新后的细胞状态，并结合输出门的控制，生成新的隐藏状态。

补充学习资源

为了更深入理解这些概念，可以参考以下资源：

1. 博客和教程
   • Understanding LSTM Networks
   • LSTM Networks by Christopher Olah
2. 视频教程
   • YouTube - LSTM Explained
3. 在线课程
   • Coursera: Sequence Models by Andrew Ng

这些资源将帮助你更好地理解 LSTM 中 tanh 函数的作用及其在隐藏状态和细胞状态更新中的角色。

---

Shortcuts for Next Step:

• input “1” for a practical implementation of LSTM with detailed explanations of each step
• input “2” for an in-depth tutorial on gate mechanisms in LSTM
• input “3” for further exploration of LSTM variants like GRU

Or, you can just type “continue” or “c”, I will continue automatically.

#tanh #lstm #hidden_state #concatenation

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-07-23-环神经网络（RNN）在处理长序列数据时，存在“短期记忆”的问题，即它们在长时间步之后难以保留早期的信息。这…

2024-07-23-环神经网络（RNN）在处理长序列数据时，存在“短期记忆”的问题，即它们在长时间步之后难以保留早期的信息。这主要是因为 RNN 中的信息在每个时间步都会被更新，随着时间步数的增加，早期的信息逐渐被后来的信息所覆盖。此外，RNN 容易受到梯度消失和梯度爆炸问题的影响，使得它们在训练过程中难以有效地捕捉长距离依赖关系。

---

layout: post title: ‘环神经网络（RNN）在处理长序列数据时，存在“短期记忆”的问题，即它们在长时间步之后难以保留早期的信息。这主要是因为 RNN 中的信息在每个时间步都会被更新，随着时间步数的增加，早期的信息逐渐被后来的信息所覆盖。此外，RNN 容易受到梯度消失和梯度爆炸问题的影响，使得它们在训练过程中难以有效地捕捉长距离依赖关系。’ date: 2024-07-23T15:49:57-04:00

---

RNN 的短期记忆问题

普通的循环神经网络（RNN）在处理长序列数据时，存在“短期记忆”的问题，即它们在长时间步之后难以保留早期的信息。这主要是因为 RNN 中的信息在每个时间步都会被更新，随着时间步数的增加，早期的信息逐渐被后来的信息所覆盖。此外，RNN 容易受到梯度消失和梯度爆炸问题的影响，使得它们在训练过程中难以有效地捕捉长距离依赖关系。

LSTM 如何解决短期记忆问题

LSTM（长短期记忆网络）通过引入一种更复杂的结构，包括记忆单元（cell state）和三个门控机制（输入门、遗忘门和输出门），有效地解决了 RNN 的短期记忆问题。

1. 记忆单元（Cell State）

LSTM 引入了一个直接流经整个序列的“记忆单元”或“细胞状态”，可以看作是一个高速公路，信息可以在其中相对不变地流动。LSTM 通过门控机制来控制信息的流入、流出和保留，从而有效地保留长期依赖信息。

2. 门控机制

LSTM 使用三个门来控制信息的流动，这些门是：

• 遗忘门（Forget Gate）：决定遗忘多少来自前一时间步的状态。 [ f_t = \sigma(W_f \cdot [h_{t-1}, x_t] + b_f) ] 遗忘门输出的值在 0 和 1 之间，表示要保留多少过去的记忆。

• 输入门（Input Gate）：决定当前时间步的输入信息有多少需要保存到记忆单元中。 [ i_t = \sigma(W_i \cdot [h_{t-1}, x_t] + b_i) ] [ \tilde{C}t = \tanh(W_C \cdot [h{t-1}, x_t] + b_C) ] 输入门控制的值在 0 和 1 之间，决定了当前输入信息对记忆单元更新的影响程度。

• 输出门（Output Gate）：决定从记忆单元中提取多少信息作为当前时间步的输出。 [ o_t = \sigma(W_o \cdot [h_{t-1}, x_t] + b_o) ] [ h_t = o_t \times \tanh(C_t) ] 输出门的值在 0 和 1 之间，决定了当前记忆单元状态有多少用于计算当前时间步的输出。

3. LSTM 的工作流程

每个时间步中，LSTM 通过以下步骤更新和计算状态：

1. 遗忘上一步的状态： [ C_t = f_t \times C_{t-1} ]

2. 将当前输入的信息写入状态： [ C_t = C_t + i_t \times \tilde{C}_t ]

3. 根据当前状态和输出门的结果计算新的隐藏状态： [ h_t = o_t \times \tanh(C_t) ]

为什么 LSTM 有效

LSTM 的这种结构允许它在长序列中保留重要信息，而不会因为时间步数的增加而丢失这些信息。具体来说：

• 遗忘门让模型可以决定丢弃哪些不再重要的信息。
• 输入门允许模型选择哪些新的信息需要加入记忆单元。
• 输出门控制了哪些部分的记忆需要输出。

通过这些门控机制，LSTM 可以在长时间步上保留和利用信息，解决了普通 RNN 中存在的短期记忆问题。

补充学习资源

为了更深入地理解这些概念，可以参考以下资源：

1. 博客和教程
   • Understanding LSTM Networks - 这篇文章提供了关于 LSTM 的深入而形象的解释。
2. 视频教程
   • YouTube - LSTM Explained - 这段视频详细解释了 LSTM 的内部工作原理。
3. 在线课程
   • Coursera: Sequence Models by Andrew Ng - 该课程详细讲解了序列模型，包括 RNN、LSTM 和 GRU。

通过这些资源，你可以更深入地了解 LSTM 是如何解决 RNN 的短期记忆问题的。

---

Shortcuts for Next Step:

• input “1” for a practical implementation of LSTM in a sequence modeling task
• input “2” for detailed explanation of GRU and its comparison with LSTM
• input “3” for further exploration of neural network architectures in sequence tasks

Or, you can just type “continue” or “c”, I will continue automatically.

#lstm #RNN #GRU

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-07-23-请解释为什么new weights = weight - learning rate * gradient…

2024-07-23-请解释为什么new weights = weight - learning rate * gradient (gradient update rule )用中文。我想知道为啥LSTM， GRU和vanilla NN 有关系。 同时请告诉我back propagation是啥。我们为什么要用

---

layout: post title: ‘请解释为什么new weights = weight - learning rate * gradient (gradient update rule )用中文。我想知道为啥LSTM， GRU和vanilla NN 有关系。 同时请告诉我back propagation是啥。我们为什么要用’ date: 2024-07-23T15:49:16-04:00

---

梯度更新规则解释

梯度更新规则中的公式：

[ \text{new weights} = \text{weights} - \text{learning rate} \times \text{gradient} ]

这个公式解释了如何更新神经网络中的权重：

1. 权重（weights）：神经网络中的参数，决定了输入数据如何经过网络的层层计算，最终产生输出。
2. 学习率（learning rate）：一个超参数，用来控制每次权重更新的步幅大小。学习率过大可能导致训练不稳定，学习率过小则可能导致收敛速度过慢。
3. 梯度（gradient）：损失函数对权重的偏导数，表示在当前点上，权重变化对损失的影响方向和大小。

通过每次迭代减去学习率乘以梯度，可以逐步调整权重，使得损失函数逐步减小，从而优化模型。

LSTM, GRU 和 Vanilla NN 的关系

1. Vanilla NN（普通神经网络）：普通的前馈神经网络，每一层的神经元与下一层的所有神经元相连，没有循环或时间序列处理能力。它们主要用于处理静态数据，例如图像分类。

2. RNN（循环神经网络）：在普通神经网络基础上增加了循环连接，可以处理序列数据。每个时间步的输出依赖于前一个时间步的状态，因此适用于时间序列、自然语言处理等任务。但 RNN 存在梯度消失和梯度爆炸问题，处理长序列时效果不好。

3. LSTM（长短期记忆网络）：对 RNN 的改进，引入了门控机制（输入门、遗忘门、输出门），使得它能更好地捕捉长距离依赖关系，缓解了梯度消失和爆炸问题。

4. GRU（门控循环单元）：对 LSTM 的简化，引入了更新门和重置门，保留了捕捉长距离依赖的能力，同时减少了参数数量，计算更高效。

反向传播（Backpropagation）

反向传播是神经网络训练中的一种算法，用于计算损失函数对各层权重的梯度，并通过这些梯度更新权重。反向传播步骤包括：

1. 前向传播（Forward Propagation）：计算输入数据经过网络后得到的输出，并根据实际值计算损失。
2. 反向传播（Backward Propagation）：从输出层开始，逐层计算损失函数对各层权重的梯度，利用链式法则将误差反向传播到每一层。
3. 权重更新：利用梯度下降法，根据计算出的梯度和学习率，更新每一层的权重。

反向传播的重要性在于：

• 高效计算梯度：通过链式法则，可以高效地计算每一层的梯度。
• 自动化训练：使得神经网络的训练过程能够自动优化，逐步减小损失函数，从而提高模型的准确性。

总结

• 梯度更新规则：通过权重减去学习率乘以梯度，逐步优化模型。
• LSTM、GRU 和 Vanilla NN 的关系：LSTM 和 GRU 是对 RNN 的改进，增强了处理长序列的能力，Vanilla NN 则是基本的前馈神经网络。
• 反向传播：通过前向传播计算损失，再通过反向传播计算梯度，最终更新权重，以优化模型。

这些概念的掌握有助于理解神经网络的训练过程和优化原理。希望这些解释对你有所帮助。

---

Shortcuts for Next Step:

• input “1” for a detailed tutorial on gradient descent and backpropagation
• input “2” for practical implementation of LSTM and GRU models
• input “3” for further resources on neural network optimization techniques

Or, you can just type “continue” or “c”, I will continue automatically.

#lstm #GRU #vanillaNN

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-07-23-fully connected layer 为什么是another name of a basic vanilla…

2024-07-23-fully connected layer 为什么是another name of a basic vanilla neural network?你能讲一下为什么我们把一个句子输入（包含很多的word） 他是怎么通过LSTM的encoder decoder的。我想知道具体的数据和矩阵操作变换，还有这些数据是怎么通过fully connected layer 的。 请帮我把这些概念和数据变换过程搞清楚。

---

layout: post title: ‘fully connected layer 为什么是another name of a basic vanilla neural network?你能讲一下为什么我们把一个句子输入（包含很多的word） 他是怎么通过LSTM的encoder decoder的。我想知道具体的数据和矩阵操作变换，还有这些数据是怎么通过fully connected layer 的。 请帮我把这些概念和数据变换过程搞清楚。’ date: 2024-07-23T15:38:34-04:00

---

Fully Connected Layer and Vanilla Neural Network

A fully connected layer, also known as a dense layer, is called another name for a basic vanilla neural network because it forms the foundational building block of many neural networks. In a fully connected layer, every neuron is connected to every neuron in the previous layer, meaning all inputs affect all outputs.

LSTM Encoder-Decoder Architecture

Let’s break down how an LSTM-based encoder-decoder model processes a sentence, including the data transformations and matrix operations involved, and how the fully connected layer (FC layer) fits into this.

1. Input Sentence and Embedding Layer

• Input Sentence: “Hello, how are you?”
• Word Embedding: Each word in the sentence is converted into a dense vector representation using an embedding layer.
  • Example:
    • “Hello” -> [0.1, 0.2, …, 0.3]
    • “how” -> [0.4, 0.5, …, 0.6]
    • “are” -> [0.7, 0.8, …, 0.9]
    • “you” -> [0.2, 0.3, …, 0.4]

2. Encoder LSTM

The embedded sentence is fed into the encoder LSTM one word at a time.

• Input Sequence:
  • X = [x_hello, x_how, x_are, x_you]
• LSTM Equations (for simplicity, omitting bias terms):
  • ( f_t = \sigma(W_f \cdot [h_{t-1}, x_t]) ) (forget gate)
  • ( i_t = \sigma(W_i \cdot [h_{t-1}, x_t]) ) (input gate)
  • ( \tilde{C}t = \tanh(W_C \cdot [h{t-1}, x_t]) ) (cell candidate)
  • ( C_t = f_t * C_{t-1} + i_t * \tilde{C}_t ) (cell state)
  • ( o_t = \sigma(W_o \cdot [h_{t-1}, x_t]) ) (output gate)
  • ( h_t = o_t * \tanh(C_t) ) (hidden state)

Each word’s embedding vector ( x_t ) is processed, and the hidden state ( h_t ) and cell state ( C_t ) are updated at each time step.

3. Context Vector

After processing all words, the final hidden state ( h_T ) and cell state ( C_T ) form the context vector, encapsulating the entire input sentence.

4. Decoder LSTM

The context vector is passed to the decoder LSTM, which generates the output sequence (e.g., translated sentence) one word at a time.

• Initial State:
  • ( h_0^{dec} = h_T^{enc} )
  • ( C_0^{dec} = C_T^{enc} )
• Output Sequence Generation:
  • The decoder uses the previous word ( y_{t-1} ) (or at start) and the current hidden state to generate the next word.
  • ( x_t^{dec} ) (input embedding of decoder) is processed similarly to the encoder, but also involves the fully connected layer for final word prediction.

5. Fully Connected Layer

The fully connected layer takes the hidden state from the decoder LSTM and maps it to the output vocabulary size, producing the logits for each possible next word.

• Equation:
  • ( y_t = \text{softmax}(W_{fc} \cdot h_t^{dec} + b_{fc}) )

  Here, ( W_{fc} ) and ( b_{fc} ) are the weights and biases of the fully connected layer.

Data Flow and Matrix Operations:

1. Embedding: Converts words to vectors.
   • Matrix multiplication between word indices and embedding matrix.
2. LSTM Cell: Processes each word embedding.
   • Multiple matrix multiplications for gates and state updates.
3. Context Vector: Final hidden and cell states from encoder.
4. Decoder Input: Initial states from context vector.
5. Decoder LSTM: Generates sequence.
6. Fully Connected Layer: Converts decoder hidden state to vocabulary logits.
   • Matrix multiplication and softmax for word prediction.

Visual Explanation and Further Learning

For a more visual and detailed explanation, including interactive elements, I recommend the following resources:

1. Understanding LSTM Networks (Blog): Colah’s Blog on LSTMs
   • This blog provides an excellent visual and intuitive explanation of how LSTMs work.
2. The Illustrated Transformer (Blog): The Illustrated Transformer
   • Though focused on transformers, it includes visual explanations of attention mechanisms that complement understanding of sequence models.
3. Deep Learning Specialization (Course): Coursera - Sequence Models by Andrew Ng
   • This course covers sequence models in-depth, including LSTM and encoder-decoder architectures.
4. Video Tutorial: YouTube - LSTM and Encoder-Decoder Video
   • This video tutorial explains the working of LSTMs and their use in encoder-decoder models.

These resources will help you understand the intricacies of LSTM-based encoder-decoder architectures, their data transformations, and the role of fully connected layers.

---

Shortcuts for Next Step:

• input “1” for a detailed code example of LSTM encoder-decoder
• input “2” for an in-depth tutorial on LSTM gates and operations
• input “3” for further resources on advanced sequence modeling

Or, you can just type “continue” or “c”, I will continue automatically.

#lstm #encoder #decoder #scratch #vanillaNN #fully_connected_layer

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-07-23-encoder和decoder的时候，要提到LSTM

---

layout: post title: ‘encoder和decoder的时候，要提到LSTM’ date: 2024-07-23T14:57:45-04:00

---

Encoder 和 Decoder 中的 LSTM 0. Encoder 部分：编码器的任务是将输入序列转换为一个固定大小的上下文向量。LSTM 的长距离依赖处理能力使其能够有效地捕捉输入序列中的关键信息，并将其编码成上下文向量。 0. Decoder 部分：解码器的任务是从上下文向量生成输出序列。LSTM 能够利用上下文向量和之前生成的输出灵活地生成新输出，使其在机器翻译等任务中表现出色。 举例子：

输入句子 (英语): [Hello, how are you?] ↓ (Encoder LSTM) ↓ 上下文向量 (Context Vector) ↓ (Decoder LSTM) ↓ 输出句子 (法语): [Bonjour, comment ça va?]

具体示例代码

以下是一个使用 LSTM 作为 Encoder 和 Decoder 的简单 Seq2Seq 模型的 PyTorch 示例：

import torch
import torch.nn as nn

class Encoder(nn.Module):
    def __init__(self, input_dim, emb_dim, hidden_dim, n_layers, dropout):
        super(Encoder, self).__init__()
        self.embedding = nn.Embedding(input_dim, emb_dim)
        self.lstm = nn.LSTM(emb_dim, hidden_dim, n_layers, dropout=dropout)
    
    def forward(self, src):
        embedded = self.embedding(src)
        outputs, (hidden, cell) = self.lstm(embedded)
        return hidden, cell

class Decoder(nn.Module):
    def __init__(self, output_dim, emb_dim, hidden_dim, n_layers, dropout):
        super(Decoder, self).__init__()
        self.embedding = nn.Embedding(output_dim, emb_dim)
        self.lstm = nn.LSTM(emb_dim, hidden_dim, n_layers, dropout=dropout)
        self.fc = nn.Linear(hidden_dim, output_dim)
    
    def forward(self, trg, hidden, cell):
        embedded = self.embedding(trg).unsqueeze(0)
        output, (hidden, cell) = self.lstm(embedded, (hidden, cell))
        prediction = self.fc(output.squeeze(0))
        return prediction, hidden, cell

class Seq2Seq(nn.Module):
    def __init__(self, encoder, decoder):
        super(Seq2Seq, self).__init__()
        self.encoder = encoder
        self.decoder = decoder
    
    def forward(self, src, trg, teacher_forcing_ratio=0.5):
        hidden, cell = self.encoder(src)
        outputs = torch.zeros(trg.size(0), trg.size(1), self.decoder.fc.out_features).to(trg.device)
        input = trg[0, :]
        
        for t in range(1, trg.size(0)):
            output, hidden, cell = self.decoder(input, hidden, cell)
            outputs[t] = output
            teacher_force = torch.rand(1).item() < teacher_forcing_ratio
            input = trg[t] if teacher_force else output.argmax(1)
        
        return outputs

#lstm #encoder #decoder

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

encoder和decoder的时候，要提到LSTM Encoder 和 Decoder 中的 LSTM 1. Encoder 部分：编码器的任务是将输入序列转换为一个固定大小的上下文向量。LSTM 的长距离依赖处理能力使其能够有效地捕捉输入序列中的关键信息，并将其编码成上下文向量。 2. Decoder 部分：解码器的任务是从上下文向量生成输出序列。LSTM 能够利用上下文向量和之前生成的输出灵活地生成新输出，使其在机器翻译等任务中表现出色。 举例子：

输入句子 (英语): [Hello, how are you?] ↓ (Encoder LSTM) ↓ 上下文向量 (Context Vector) ↓ (Decoder LSTM) ↓ 输出句子 (法语): [Bonjour, comment ça va?]

具体示例代码

以下是一个使用 LSTM 作为 Encoder 和 Decoder 的简单 Seq2Seq 模型的 PyTorch 示例：

import torch
import torch.nn as nn

class Encoder(nn.Module):
    def __init__(self, input_dim, emb_dim, hidden_dim, n_layers, dropout):
        super(Encoder, self).__init__()
        self.embedding = nn.Embedding(input_dim, emb_dim)
        self.lstm = nn.LSTM(emb_dim, hidden_dim, n_layers, dropout=dropout)
    
    def forward(self, src):
        embedded = self.embedding(src)
        outputs, (hidden, cell) = self.lstm(embedded)
        return hidden, cell

class Decoder(nn.Module):
    def __init__(self, output_dim, emb_dim, hidden_dim, n_layers, dropout):
        super(Decoder, self).__init__()
        self.embedding = nn.Embedding(output_dim, emb_dim)
        self.lstm = nn.LSTM(emb_dim, hidden_dim, n_layers, dropout=dropout)
        self.fc = nn.Linear(hidden_dim, output_dim)
    
    def forward(self, trg, hidden, cell):
        embedded = self.embedding(trg).unsqueeze(0)
        output, (hidden, cell) = self.lstm(embedded, (hidden, cell))
        prediction = self.fc(output.squeeze(0))
        return prediction, hidden, cell

class Seq2Seq(nn.Module):
    def __init__(self, encoder, decoder):
        super(Seq2Seq, self).__init__()
        self.encoder = encoder
        self.decoder = decoder
    
    def forward(self, src, trg, teacher_forcing_ratio=0.5):
        hidden, cell = self.encoder(src)
        outputs = torch.zeros(trg.size(0), trg.size(1), self.decoder.fc.out_features).to(trg.device)
        input = trg[0, :]
        
        for t in range(1, trg.size(0)):
            output, hidden, cell = self.decoder(input, hidden, cell)
            outputs[t] = output
            teacher_force = torch.rand(1).item() < teacher_forcing_ratio
            input = trg[t] if teacher_force else output.argmax(1)
        
        return outputs

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-07-23-embedding和encoding解惑

---

layout: post title: ‘embedding和encoding解惑’ date: 2024-07-23T14:53:04-04:00

---

Embedding为每个词创建了2个嵌入值（即向量的维度是2）

嵌入（Embedding） 嵌入（Embedding） 是将高维离散变量（如词语）转换为低维连续向量表示的方法。每个词语在嵌入层中都被表示为一个向量，这个向量通常有数百或数千个维度，用于捕捉词语的语义信息和上下文关系。 举例说明 假设我们有一个简单的句子：”Hello world”。我们通常会对每个词进行嵌入。嵌入层会将词语转换为向量，例如： “Hello” -> [0.5, -0.3] “world” -> [0.1, 0.8] 在这个例子中，我们为每个词创建了2个嵌入值（即向量的维度是2）。但是，在实际应用中，我们通常会使用更高维度的嵌入，例如100维、300维甚至更多： “Hello” -> [0.5, -0.3, 0.2, …, 0.1] “world” -> [0.1, 0.8, -0.4, …, 0.7] 使用更高维度的嵌入可以更好地捕捉词语之间的复杂关系和语义信息。

Encoding 和embedding的区别是，encoding是把词汇对应成为为一个ID， 但是embedding是吧token转换成为高纬度的向量。

Transformer = encoder+decoder。 encoder和decoder都是有很多的layer组成的， 每个layer都有自己的sublayer。这里的sublayer一般只有两个，也就是multi-headed self-attention mechanism 和feedforward neural network.(FFNN)

⁃	Multihead是对输入序列进行加权求和，以捕捉序列中不同位置的依赖关系。
⁃	FFNN是对自注意力机制的输出进行下一步的非线性变换。FFNN= 两个线性变换（全连接层）+非线性激活函数（ReLU） ： [ FFN(x) = \max(0, xW_1 + b_1)W_2 + b_2 ]
•	其中，(W_1)、(W_2) 是权重矩阵，(b_1)、(b_2) 是偏置向量，(\max(0, x)) 是 ReLU 激活函数。 FFNN: Linear -> ReLU -> Linear

#encoding #decoding #FFNN #ReLU #multiheadead_self_attention

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Embedding为每个词创建了2个嵌入值（即向量的维度是2） 嵌入（Embedding） 嵌入（Embedding） 是将高维离散变量（如词语）转换为低维连续向量表示的方法。每个词语在嵌入层中都被表示为一个向量，这个向量通常有数百或数千个维度，用于捕捉词语的语义信息和上下文关系。 举例说明 假设我们有一个简单的句子：”Hello world”。我们通常会对每个词进行嵌入。嵌入层会将词语转换为向量，例如： “Hello” -> [0.5, -0.3] “world” -> [0.1, 0.8] 在这个例子中，我们为每个词创建了2个嵌入值（即向量的维度是2）。但是，在实际应用中，我们通常会使用更高维度的嵌入，例如100维、300维甚至更多： “Hello” -> [0.5, -0.3, 0.2, …, 0.1] “world” -> [0.1, 0.8, -0.4, …, 0.7] 使用更高维度的嵌入可以更好地捕捉词语之间的复杂关系和语义信息。

Encoding 和embedding的区别是，encoding是把词汇对应成为为一个ID， 但是embedding是吧token转换成为高纬度的向量。

Transformer = encoder+decoder。 encoder和decoder都是有很多的layer组成的， 每个layer都有自己的sublayer。这里的sublayer一般只有两个，也就是multi-headed self-attention mechanism 和feedforward neural network.(FFNN)

⁃	Multihead是对输入序列进行加权求和，以捕捉序列中不同位置的依赖关系。
⁃	FFNN是对自注意力机制的输出进行下一步的非线性变换。FFNN= 两个线性变换（全连接层）+非线性激活函数（ReLU） ： [ FFN(x) = \max(0, xW_1 + b_1)W_2 + b_2 ]
•	其中，(W_1)、(W_2) 是权重矩阵，(b_1)、(b_2) 是偏置向量，(\max(0, x)) 是 ReLU 激活函数。 FFNN: Linear -> ReLU -> Linear

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-07-23-browser的设置问题

---

layout: post title: ‘browser的设置问题 ‘ date: 2024-07-23T13:20:20-04:00

---

safari用来看YouTube可以翻译中文。 因为有插件immersive translator。iPad可以用，比较干净，如果有YouTube上的学习资源，可以在safari的reading list上继续观看，同时0.75倍速去学习这个材料。

Google上可以对YouTube ,Udemy, Netflix 都进行翻译中文，比较适合日常的每一项工作，所以defaul browser还是应该选择Google。 插件的名字叫language reactor， 和udemy subtitle translate

#browser #google #safari #extension

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-07-22-tensorflow 和pytorch 我该选哪一个。

---

layout: post title: ‘tensorflow 和pytorch 我该选哪一个。’ date: 2024-07-22T16:42:38-04:00

---

TensorFlow 和 PyTorch 是两种流行的深度学习框架，它们各有优点和适用场景。以下是它们的一些主要区别和特点：

TensorFlow

优点：

1. 成熟性和社区支持：TensorFlow 是由 Google 开发并维护的，拥有非常活跃的社区和丰富的资源。
2. 部署灵活性：TensorFlow 在生产环境中的部署非常成熟，可以方便地部署到各种平台，包括移动设备和嵌入式设备。
3. 生态系统丰富：TensorFlow 生态系统包括 TensorFlow Serving、TensorFlow Lite、TensorFlow.js 等工具，可以覆盖从训练到部署的全流程需求。
4. 图计算：支持静态图计算（TensorFlow 2.x 也支持动态图），适合生产环境中的优化和部署。

缺点：

1. 学习曲线：相比 PyTorch，TensorFlow 的学习曲线更陡峭。
2. 灵活性：早期版本的 TensorFlow 灵活性较差，虽然 TensorFlow 2.x 引入了 Eager Execution 提高了灵活性，但在一些场景下仍然不如 PyTorch。

PyTorch

优点：

1. 易于使用：PyTorch 的代码风格和调试方式更接近于 Python，本身更直观，适合研究和开发阶段。
2. 动态图计算：默认使用动态图计算（Eager Execution），更符合 Python 用户的习惯，代码编写和调试更方便。
3. 社区和发展速度：PyTorch 社区发展迅速，特别在学术界和研究领域有很高的接受度，很多新的研究论文和模型都首先在 PyTorch 上实现。

缺点：

1. 部署和生产：虽然 PyTorch 也在逐步完善部署工具（如 TorchServe），但在生产环境中的部署相对于 TensorFlow 还略显不足。
2. 生态系统：相比 TensorFlow，PyTorch 的生态系统稍逊一筹，但也在快速发展。

哪一个比较好？

选择 TensorFlow 还是 PyTorch 取决于你的具体需求和使用场景：

• 如果你的项目重视生产环境的部署和优化，且需要一个成熟的生态系统，那么 TensorFlow 可能更适合你。
• 如果你注重开发阶段的灵活性和易用性，特别是进行研究和快速原型开发，那么 PyTorch 是一个很好的选择。

实际使用场景：

• 学术研究和快速原型开发：PyTorch
• 大规模生产环境部署和综合生态系统：TensorFlow

希望这些信息对你选择合适的深度学习框架有所帮助。如果你有更多具体的需求或场景，可以进一步探讨。

---

Shortcuts for Next Step:

• input “1” for TensorFlow example project
• input “2” for PyTorch example project
• input “3” for comparison of specific features

Or, you can just type “continue” or “c”, I will continue automatically.

#tensorflow #pytorch

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

tokenizer就是分词器

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-07-22-embedding 和encoding 的区别

---

layout: post title: ‘embedding 和encoding 的区别’ date: 2024-07-22T08:46:57-04:00

---

Embedding 和 encoding 在自然语言处理（NLP）中的概念虽然相关，但它们指的是不同的步骤和处理方法。让我们来详细解释这两者的区别。

Encoding

Encoding 是指将文本数据（如单词或子词）转换成数字表示的过程。这个过程包括分词和将每个词或子词映射到词汇表中的唯一 ID。

示例：假设我们有一个句子 “I love NLP”。

1. 分词（Tokenization）：
   • 输入句子：”I love NLP”
   • 分词结果：[“I”, “love”, “N”, “##L”, “##P”]
2. 映射到 ID（Mapping to IDs）：
   • 每个词或子词在词汇表中都有一个唯一的 ID
   • 例如，[“I” -> 1, “love” -> 2, “N” -> 3, “##L” -> 4, “##P” -> 5]

结果：输入句子 “I love NLP” 被编码成 [1, 2, 3, 4, 5]

Embedding

Embedding 是指将这些离散的 token ID 转换为连续的、高维度的向量表示。这些向量表示捕捉了单词或子词之间的语义关系。Embedding 通常在训练过程中学习得到，使得具有相似语义的词在向量空间中靠近。

Embedding 的过程

1. 词嵌入矩阵（Embedding Matrix）：
   • 词嵌入矩阵是一个大小为 (V \times D) 的矩阵，其中 (V) 是词汇表的大小，(D) 是嵌入向量的维度。
   • 每个词 ID 对应矩阵中的一行，即该词的嵌入向量。
2. 将 ID 映射到嵌入向量：
   • 输入的 token ID 序列 [1, 2, 3, 4, 5]
   • 使用词嵌入矩阵，将每个 ID 映射到对应的向量

示例：假设我们有一个词嵌入矩阵 (E)，其中第 i 行表示第 i 个词的嵌入向量 (e_i)。

E = [
  e_1,  # Embedding for "I"
  e_2,  # Embedding for "love"
  e_3,  # Embedding for "N"
  e_4,  # Embedding for "##L"
  e_5,  # Embedding for "##P"
  ...
]

将 ID 序列 [1, 2, 3, 4, 5] 映射到嵌入向量：

[
  e_1,  # Embedding for "I"
  e_2,  # Embedding for "love"
  e_3,  # Embedding for "N"
  e_4,  # Embedding for "##L"
  e_5,  # Embedding for "##P"
]

总结

• Encoding 是将文本转换为 token ID 的过程，这是模型处理文本的第一步。
• Embedding 是将 token ID 转换为连续的、高维度的向量表示，用于捕捉词与词之间的语义关系。

虽然这两个过程都是将文本数据转换为模型可以处理的形式，但 encoding 处理的是离散的标识符（ID），而 embedding 处理的是这些标识符在连续空间中的向量表示。

#embedding #encoding #transformer

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-07-22-FFNN feedforwardneuralnetworks transformer languagemodel…

2024-07-22-FFNN feedforwardneuralnetworks transformer languagemodel decoder

---

layout: post title: ‘FFNN feedforwardneuralnetworks transformer languagemodel decoder’ date: 2024-07-22T08:24:16-04:00

---

在 Transformer 语言模型的解码器（decoder）中，前馈神经网络（Feedforward Neural Network，FFNN）是一个重要的组成部分。让我们逐步理解其含义及作用。

前馈神经网络 (Feedforward Neural Network)

前馈神经网络是一种最基本的神经网络架构，通常由多个全连接层组成，每层的神经元与下一层的神经元全部连接。它们之所以称为“前馈”，是因为信息从输入层经过隐藏层到输出层是单向流动的，没有环回。

Transformer 的结构

Transformer 是一种序列到序列的模型架构，广泛用于自然语言处理任务。Transformer 由编码器（encoder）和解码器（decoder）两部分组成，每部分包含多个层（layers）。每一层都包括两个主要的子层（sublayers）：

1. 多头自注意力机制（Multi-head Self-Attention Mechanism）
2. 前馈神经网络（Feedforward Neural Network）

FFNN 在 Transformer 解码器中的作用

在 Transformer 解码器的每一层中，FFNN 子层通常位于多头自注意力机制子层之后。具体步骤如下：

1. 多头自注意力机制：这一步对输入序列进行加权求和，以捕捉序列中不同位置之间的依赖关系。

2. 前馈神经网络：这个子层对来自注意力机制的输出进行进一步的非线性变换。具体来说，前馈神经网络通常由两个线性变换（全连接层）和一个非线性激活函数（通常是 ReLU）组成。公式表示如下：

   [ FFN(x) = \max(0, xW_1 + b_1)W_2 + b_2 ]

   其中，(W_1)、(W_2) 是权重矩阵，(b_1)、(b_2) 是偏置向量，(\max(0, x)) 是 ReLU 激活函数。

作用与意义

1. 非线性变换：FFNN 引入了非线性变换，使得模型能够表示更复杂的函数，从而提高了模型的表达能力。
2. 特征抽取：通过线性变换和非线性激活，FFNN 能够进一步抽取和转换特征，有助于捕捉输入数据中的更高层次的特征。
3. 计算效率：FFNN 只涉及简单的矩阵乘法和激活函数计算，相比注意力机制，计算效率更高，因此在 Transformer 中非常适合作为特征变换的子层。

总结来说，前馈神经网络在 Transformer 语言模型的解码器中，通过对多头自注意力机制的输出进行非线性变换和特征抽取，增强了模型的表示能力和计算效率，使得模型能够更好地处理和生成自然语言文本。

#FFNN #transformer #decoder

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-07-19-最快掌握lstm和attention的学习路线

---

layout: post title: ‘最快掌握lstm和attention的学习路线’ date: 2024-07-19T16:13:50-04:00

---

快速学习与实现LSTM结合Attention模型的路径规划

为了在最短时间内掌握LSTM和Attention机制并实现用于车辆轨迹预测的模型，建议进行高效的学习和实践。以下是一个加速的学习计划和资源推荐。

一、时间规划

第一周：RNN和LSTM

• 学习内容：
  • 基本概念和工作原理
  • 简单的LSTM模型实现
• 资源：
  • Understanding LSTM Networks
  • Deep Learning Specialization by Andrew Ng on Coursera
• 实践：
  • 实现一个基本的LSTM模型并训练一个简单的数据集

第二周：经典的Encoder-Decoder架构和Attention机制

• 学习内容：
  • Encoder-Decoder架构的基本概念
  • Attention机制的工作原理
• 资源：
  • Sequence to Sequence Learning with Neural Networks
  • Neural Machine Translation by Jointly Learning to Align and Translate
  • Illustrated Attention
• 实践：
  • 实现带有Attention机制的Seq2Seq模型

第三周：Transformer模型

• 学习内容：
  • Transformer的基本结构和原理
• 资源：
  • Attention is All You Need
  • Illustrated Transformer
  • Hugging Face Transformers库
• 实践：
  • 使用Hugging Face库实现一个简单的Transformer模型

第四周：车辆轨迹数据处理和特征工程

• 学习内容：
  • 数据预处理和特征提取
  • 车辆轨迹数据的特征工程
• 资源：
  • Kaggle上的时序数据竞赛和数据集
  • Python for Data Analysis by Wes McKinney
• 实践：
  • 获取并清洗车辆轨迹数据，进行特征提取和工程

第五周：实现LSTM与Attention结合的模型

• 学习内容：
  • 将LSTM和Attention机制结合的具体实现
  • 模型训练和调优
• 资源：
  • Keras Documentation
  • TensorFlow Documentation
• 实践：
  • 实现并训练结合LSTM和Attention的车辆轨迹预测模型
  • 进行模型调优和验证

详细学习内容和步骤

1. RNN和LSTM基础

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense

model = Sequential()
model.add(LSTM(50, return_sequences=True, input_shape=(n_timesteps, n_features)))
model.add(LSTM(50))
model.add(Dense(1))
model.compile(optimizer='adam', loss='mse')

model.fit(X_train, y_train, epochs=50, batch_size=64, validation_data=(X_test, y_test))

2. Encoder-Decoder架构和Attention机制

from tensorflow.keras.layers import Input, LSTM, Dense, Attention
from tensorflow.keras.models import Model

# Encoder
encoder_inputs = Input(shape=(None, num_features))
encoder_lstm = LSTM(latent_dim, return_state=True)
encoder_outputs, state_h, state_c = encoder_lstm(encoder_inputs)
encoder_states = [state_h, state_c]

# Decoder
decoder_inputs = Input(shape=(None, num_features))
decoder_lstm = LSTM(latent_dim, return_sequences=True, return_state=True)
decoder_outputs, _, _ = decoder_lstm(decoder_inputs, initial_state=encoder_states)
attention = Attention()
attention_output = attention([decoder_outputs, encoder_outputs])
decoder_dense = Dense(num_features, activation='softmax')
decoder_outputs = decoder_dense(attention_output)

model = Model([encoder_inputs, decoder_inputs], decoder_outputs)
model.compile(optimizer='rmsprop', loss='categorical_crossentropy')
model.fit([encoder_input_data, decoder_input_data], decoder_target_data,
          batch_size=batch_size, epochs=epochs, validation_split=0.2)

3. 使用Hugging Face的Transformer模型

from transformers import BertTokenizer, TFBertModel

tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = TFBertModel.from_pretrained('bert-base-uncased')

inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
outputs = model(inputs)

4. 数据预处理和特征工程

import pandas as pd

# 假设我们有一个包含车辆轨迹数据的DataFrame
data = pd.read_csv('vehicle_trajectories.csv')

# 特征提取示例
data['speed'] = data['distance'] / data['time']
data['acceleration'] = data['speed'].diff() / data['time'].diff()

# 数据清洗
data.dropna(inplace=True)

5. 实现LSTM与Attention结合的车辆轨迹预测模型

from tensorflow.keras.layers import Input, LSTM, Dense, Attention, Concatenate
from tensorflow.keras.models import Model

input_seq = Input(shape=(n_timesteps, n_features))
lstm_out = LSTM(50, return_sequences=True)(input_seq)
attention_out = Attention()([lstm_out, lstm_out])
concat = Concatenate()([lstm_out, attention_out])
dense_out = Dense(1)(concat)

model = Model(inputs=input_seq, outputs=dense_out)
model.compile(optimizer='adam', loss='mse')

model.fit(X_train, y_train, epochs=50, batch_size=64, validation_data=(X_test, y_test))

快速参考资源

1. 课程
   • Deep Learning Specialization by Andrew Ng on Coursera
   • Advanced NLP with SpaCy
2. 书籍
   • “Deep Learning” by Ian Goodfellow, Yoshua Bengio, and Aaron Courville
   • “Neural Networks and Deep Learning” by Michael Nielsen
3. 在线资源
   • Hugging Face Transformers Documentation
   • Kaggle（时序数据竞赛和数据集）

通过这个加速的学习路径和资源，你可以在大约5周内掌握LSTM和Attention机制，并实现用于车辆轨迹预测的模型。

---

Shortcuts for Next Step:

• input “1” for 继续深入学习Attention机制的实现细节
• input “2” for 学习如何在实际数据集上训练和评估你的模型
• input “3” for 了解更多关于时间序列预测的高级技巧

Or, you can just type “continue” or “c”, I will continue automatically.

#Attention #lstm #seq2seq #encoderdecoder #transformer

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-07-18-新单词

---

layout: post title: ‘新单词’ date: 2024-07-18T15:21:03-04:00

---

resentment

#english

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-07-18-vscode GitHub 账号登不上，或者push不了的问题

---

layout: post title: ‘vscode GitHub 账号登不上，或者push不了的问题’ date: 2024-07-18T13:10:30-04:00

---

由于你在推送代码时没有机会输入 Personal Access Token (PAT)，可能是因为 Git 缓存了旧的凭据。你可以尝试以下步骤来清除旧的凭据并重新配置。

1. 清除存储的旧凭据

你可以通过以下命令来清除 Git 的凭据缓存：

git credential-cache exit

2. 删除 Git 凭据管理器中的旧凭据

如果你使用了 Git 凭据管理器（Credential Manager），你需要删除其中存储的旧凭据。

在 macOS 上删除凭据

1. 打开 钥匙串访问（Keychain Access）。
2. 在左侧选择 登录 钥匙串和 密码 类别。
3. 搜索 github.com。
4. 删除与 GitHub 相关的所有条目。

3. 设置新的远程仓库 URL 并推送代码

确保远程仓库 URL 设置正确，然后重新推送代码。

1. 设置远程仓库 URL：

    git remote set-url origin https://github.com/Jynxzzz/Udemy-Courses.git
   

2. 推送代码到远程仓库：

    git push -u origin main
   

3. 当系统提示输入用户名和密码时：
   • 在用户名字段中输入你的 GitHub 用户名。
   • 在密码字段中粘贴你的 PAT。

4. 强制要求输入凭据

你可以通过以下命令强制要求 Git 重新输入凭据：

git config --global credential.helper ""

示例操作步骤

1. 清除旧凭据缓存：

    git credential-cache exit
   

2. 删除钥匙串访问中的旧凭据。
   • 打开 钥匙串访问，删除与 github.com 相关的条目。
3. 强制 Git 重新输入凭据：

    git config --global credential.helper ""
   

4. 设置远程仓库 URL：

    git remote set-url origin https://github.com/Jynxzzz/Udemy-Courses.git
   

5. 推送代码：

    git push -u origin main
   

6. 输入用户名和 PAT：
   • 用户名：你的 GitHub 用户名
   • 密码：你的 PAT

通过这些步骤，你应该能够清除旧的凭据并重新配置新的 PAT，从而成功推送代码到 GitHub。如果仍然有问题，请告诉我。

---

Shortcuts for Next Step:

• input “1” for 配置 GitHub SSH key 以避免每次推送时输入密码
• input “2” for 创建和管理 GitHub 分支
• input “3” for 在 VSCode 中设置自动化脚本以简化工作流

Or, you can just type “continue” or “c”, I will continue automaticlly.

#github #vscode #push

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-04-19-路径跟踪”（path tracking）

---

layout: post title: ‘路径跟踪”（path tracking） ‘ date: 2024-04-19T15:33:33-04:00

–

 我觉得你想错了。因为我红色的点就是通过多项式拟合来的。我的目的是通过红色的点，选择连续的蓝色的道路点，你能明白吗，就是不能突兀，很自然的过渡到未来的蓝色的点，要跟现在的趋势相同的。 你看图上，我的选择并没有往回选择蓝色的点，因为我知道，太突然了，不可能有轨迹是那样的。

明白了，如果红色点已经是通过拟合得到的，那么你的目的是要选择一组连续的蓝色道路点来形成一个平滑的、符合当前趋势的路径。这个过程通常称为“路径跟踪”（path tracking）。我们可以使用如下步骤：

1. 基于趋势方向筛选蓝色点：根据红色点确定的趋势方向，选择那些与这个方向大致一致的蓝色点。

2. 排序连续的蓝色点：将这些蓝色点按照在趋势方向上的位置排序，以便形成连续的路径。

3. 平滑路径：确保路径平滑，可能需要进一步筛选或者对蓝色点进行插值处理。

下面提供一个示意性的代码：

import numpy as np

# 假设已经有了趋势方向的单位向量 trend_direction
# 这个趋势方向可以通过红色点的起点和终点来确定
start_point = red_points[0]  # 起点
end_point = red_points[-1]   # 终点
trend_direction = (end_point - start_point)
trend_direction /= np.linalg.norm(trend_direction)

# 1. 基于趋势方向筛选蓝色点
# 计算每个蓝色点到红色路径起点的向量
vectors_to_blue_points = blue_points - start_point

# 计算这些向量与趋势方向的点积，以确定它们是否在趋势方向上
dot_products = np.dot(vectors_to_blue_points, trend_direction)

# 选择点积为正的点，这些点在趋势方向上
forward_blue_points = blue_points[dot_products > 0]

# 2. 排序连续的蓝色点
# 基于它们在趋势方向上的投影排序
sorted_indices = np.argsort(dot_products[dot_products > 0])
sorted_forward_blue_points = forward_blue_points[sorted_indices]

# 3. 平滑路径
# 确保所选点形成平滑路径，如果需要，可使用插值或其他平滑技术

# 这里，我们简单地选择一定数量的连续点来表示路径
# 假设我们需要未来的10个点作为路径
path_points = sorted_forward_blue_points[:10]

# 可视化结果
plt.figure(figsize=(10, 8))
plt.plot(blue_points[:, 0], blue_points[:, 1], 'o', color='blue', label='Lane Points')
plt.plot(red_points[:, 0], red_points[:, 1], 'o', color='red', label='Detected Path Points')
plt.plot(path_points[:, 0], path_points[:, 1], 'x', color='green', label='Selected Path Points')
plt.legend()
plt.show()

请注意，这个代码是一个示意性的实现，具体的实现需要根据你的具体情况进行调整。在你的应用中，可能需要综合考虑车辆的动力学特性、路径的可行驶性、以及其他导航信息。在现实应用中，这个问题可能还需要考虑道路曲率、交通规则等复杂因素。

#path #tracking

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-02-21-gymnasium在jupyter notebook 里render播放动画

---

layout: post title: ‘gymnasium在jupyter notebook 里render播放动画’ date: 2024-02-21T19:08:22-05:00

---

感谢你的赞赏！确实，一开始看起来这种方法可能会感觉有些复杂，但其实它遵循了一套简单的模式。你不需要死记硬背；理解了基本的流程和几个关键函数之后，你可以很容易地将其应用到其他项目或环境中。下面，我会提供一个简化的模板，并解释每个部分的作用，这样你就可以根据需要调整和复用它。

Jupyter Notebook 中可视化 Gymnasium 环境的模板

import gymnasium as gym
import matplotlib.pyplot as plt
from IPython import display

# 创建环境，设置为返回RGB数组
env = gym.make("YourEnvironmentHere", render_mode="rgb_array")
observation, info = env.reset(seed=42)  # 可选：设置种子以获得可重复的结果

# 用于显示环境帧的函数
def show_frame(frame):
    plt.imshow(frame)
    plt.axis('off')  # 不显示坐标轴
    display.display(plt.gcf())  # 显示图像
    display.clear_output(wait=True)  # 清除上一帧图像

# 主循环
for _ in range(num_steps):  # num_steps 是你想运行的步数
    frame = env.render()  # 获取当前帧
    show_frame(frame)  # 显示当前帧
    
    action = env.action_space.sample()  # 随机选择一个动作，这里你可以替换为你的策略
    observation, reward, terminated, truncated, info = env.step(action)  # 执行动作
    
    if terminated or truncated:  # 检查是否结束
        observation, info = env.reset()  # 重置环境

env.close()  # 关闭环境

模板解释

• 环境创建：使用 gym.make() 创建你的环境实例，并通过 render_mode="rgb_array" 设置以便环境返回RGB数组。
• 显示函数：定义一个 show_frame() 函数，它使用 matplotlib 和 IPython.display 来显示和更新环境的帧。
• 主循环：执行一个循环，其中包括渲染当前帧、显示当前帧、选择和执行动作以及检查环境是否结束。如果环境结束，就重置它。

使用建议

• 调整环境：将 "YourEnvironmentHere" 替换为你想使用的 Gymnasium 环境的名字。
• 自定义策略：替换 env.action_space.sample() 以实现你的策略，而不是随机选择动作。
• 调整步数：根据需要修改 num_steps 的值，以控制循环的迭代次数。

这个模板提供了一个简单、灵活的方式来在 Jupyter Notebook 中可视化任何 Gymnasium 环境。一旦你熟悉了这个流程，就可以轻松地调整和扩展以适应不同的需求和环境。希望这能帮助你更加轻松地探索和学习强化学习！

#gymnasium #jupyternotebook #render #IPythondisplay

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-02-16-为啥0就是删除了这个维度啊？？

---

layout: post title: ‘为啥0就是删除了这个维度啊？？’ date: 2024-02-16T22:23:31-05:00

---

在NumPy或JAX中，当你通过指定索引来选择数组的某个维度的单个元素时，这个维度就会被”消除”，即结果中不再包含这个维度。这不是删除或丢弃数据，而是因为你选择了该维度的一个特定值，所以返回的结果就不再需要这个维度来表示。

例如，假设你有一个形状为(3, 4, 5)的数组，这个形状表示3个不同的”批次”，每个”批次”有4个”对象”，每个”对象”有5个”特征”。

如果你选择第一个”时间步”（假设时间步维度是第二维，即axis=1），比如通过array[:, 0, :]，你就会得到一个形状为(3, 5)的数组。这里，原来的第二维（”对象”维度）被选择了一个特定的值（索引为0的对象），所以在结果中就不再需要这个维度了。

在你的例子中：

data=stacked[..., 0, :]

• stacked的形状是(..., num_objects, num_timesteps=1, 5)。
• 当你使用[..., 0, :]选择时，你实际上是在说：“对于所有的批次（...）和所有的对象（第二个...），我只想要第0个时间步的数据（0），并保留所有的特征（最后一个:）。”
• 因为num_timesteps=1，选择第0个时间步意味着你正在取出这个维度唯一的元素，结果中就不再需要表示时间步这个维度，因此这个维度被”消除”。

这就是为什么选择操作会”删除”一个维度的原因。它实际上是因为在结果中不再需要这个维度来表示数据了。

#jax #numpy #dimention #slice_out #inverse

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-02-12-axis=0（行方向）进行操作时，想象你是在垂直方向添加或修改这个表格。 为什么你默认一开始就是垂直的来…

2024-02-12-axis=0（行方向）进行操作时，想象你是在垂直方向添加或修改这个表格。 为什么你默认一开始就是垂直的来修改 而不是水平的

---

layout: post title: ‘axis=0（行方向）进行操作时，想象你是在垂直方向添加或修改这个表格。 为什么你默认一开始就是垂直的来修改 而不是水平的 ‘ date: 2024-02-12T15:52:51-05:00

---

这个问题触及了如何解释和可视化多维数组操作中的axis参数，特别是对于初学者来说可能会感到困惑。选择将axis=0视为垂直操作（即操作行）的原因，与多维数组（尤其是二维数组）的传统解释和表示方式有关。

二维数组的传统表示

在多数情况下，二维数组被视为矩阵或表格，其中：

• 第一维（axis=0）表示行。
• 第二维（axis=1）表示列。

行和列的传统视角

这种将axis=0与行相关联的视角源自于矩阵和表格的传统表示法，我们通常是先说行数再说列数。例如，一个形状为(3, 2)的数组表示有3行2列。这种表示法遵循了阅读和书写的自然顺序（在大多数语言中是从上到下，从左到右），先确定“垂直位置”（行），再确定“水平位置”（列）。

为什么axis=0与垂直方向关联？

基于上述传统表示，当我们说沿着axis=0进行操作时，我们实际上是在引用数组的第一维，即行。因此，当你沿着axis=0添加、删除或拼接数据时，你是在垂直方向上改变表格的结构，即增加或减少行数。

可视化帮助理解

这种解释方式有助于可视化和理解操作的效果。如果你沿着axis=0拼接两个数组，你可以想象自己是在表格的底部添加更多的行。这种可视化方式与我们如何在现实世界中处理文档和表格相匹配，其中我们通常会在现有页面的下方添加更多的内容。

结论

将axis=0默认理解为垂直方向的操作并非唯一可能的解释方式，但它是建立在矩阵和表格的传统表示法上的一种直观方法。这种方法有助于在处理数组和进行数据操作时，快速理解和记忆axis参数的作用。

#axis #dimention

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-02-11-vmap 是 JAX 中的一个函数，用于自动将普通函数向量化，以便在数组的批处理维度上并行执行。

---

layout: post title: ‘vmap 是 JAX 中的一个函数，用于自动将普通函数向量化，以便在数组的批处理维度上并行执行。’ date: 2024-02-11T12:38:25-05:00

---

在这段代码中：

if hasattr(batch_element, 'shape'):
    ndims = len(batch_element.shape)
else:
    return func

• if hasattr(batch_element, 'shape'): 这一行检查 batch_element 对象是否有一个名为 shape 的属性。这通常用于检查对象是否是一个数组或者类似数组的数据结构，因为在 Python 中，像 NumPy 数组或 JAX 数组这样的数据结构会有一个 shape 属性，描述数组的维度。如果 batch_element 有 shape 属性，那意味着它可能是一个数组或者类似数组的对象。

• ndims = len(batch_element.shape)：如果 batch_element 确实有 shape 属性，这行代码就会计算它的长度，也就是数组的维度数（即数组是多少维的）。batch_element.shape 返回一个元组，包含数组每个维度的大小，而 len(...) 函数则返回这个元组的长度，即数组的维度数。例如，如果 batch_element 是一个形状为 (3, 4, 5) 的三维数组，那么 batch_element.shape 会是 (3, 4, 5)，而 len(batch_element.shape) 的结果则是 3。

• else: return func：如果 batch_element 没有 shape 属性，这意味着它可能不是一个数组或类似数组的对象，那么函数就直接返回未经任何修改的原始函数 func。这种情况下，不会对 func 应用任何 vmap 操作。

简而言之，这段代码的目的是检查给定的 batch_element 是否是数组或类似数组的对象，如果是，就计算它的维度数，这对后续可能需要应用 vmap 的操作很有帮助。vmap 是 JAX 中的一个函数，用于自动将普通函数向量化，以便在数组的批处理维度上并行执行。

#vmap #jax #func #waymax #batch_element

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-02-11-as_action方法则提供了将轨迹更新转换为动作的便利途径，使得不同的动力学模型能够在统一的框架下交互…

2024-02-11-as_action方法则提供了将轨迹更新转换为动作的便利途径，使得不同的动力学模型能够在统一的框架下交互。

---

layout: post title: ‘as_action方法则提供了将轨迹更新转换为动作的便利途径，使得不同的动力学模型能够在统一的框架下交互。’ date: 2024-02-11T01:19:15-05:00

---

这段代码定义了一个名为TrajectoryUpdate的数据结构，用于在仿真环境中保存可由动力学模型更新的轨迹部分，如位置和速度。下面详细解释这个类的构成及其功能：

使用@chex.dataclass

@chex.dataclass
class TrajectoryUpdate:

@chex.dataclass是一个装饰器，用于自动生成dataclass，同时加入了类型检查和形状验证的功能。这使得定义包含数组的数据结构变得更加方便，同时确保数据类型和形状的正确性。

类属性

• x, y, yaw, vel_x, vel_y: 这些属性分别代表对象的x位置、y位置、朝向角、x方向速度和y方向速度。它们都是jax.Array类型，形状为(..., num_objects, 1)，其中num_objects是仿真中对象的数量。
• valid: 一个布尔数组，指示每个对象的状态更新是否有效，形状也是(..., num_objects, 1)。

@property 方法

@property
def shape(self) -> tuple[int, ...]:

shape属性返回valid数组的形状，这通常反映了仿真中对象的数量。

__eq__ 方法

def __eq__(self, other: Any) -> bool:

这个方法用于比较两个TrajectoryUpdate实例是否相等。它通过比较所有字段的值来实现，使用operations.compare_all_leaf_nodes函数（这里假设operations是定义了比较逻辑的模块）。

validate 方法

def validate(self) -> None:

这个方法用于验证TrajectoryUpdate实例的形状和类型是否符合预期。它使用chex库的assert_equal_shape和assert_type函数来检查所有字段的形状是否一致，并且具有正确的数据类型。

as_action 方法

def as_action(self) -> Action:

as_action方法将TrajectoryUpdate实例转换为StateDynamics可用的5D动作格式。这是通过将x, y, yaw, vel_x, vel_y沿最后一个维度拼接成一个新的数组实现的，其结果是一个形状为(..., 5)的数组，随后被封装成Action数据结构并返回。这样，轨迹更新就可以直接作为动力学模型的输入使用。

总结

TrajectoryUpdate类是仿真环境中一个重要的组件，它提供了一种标准化的方式来表达动力学模型可能进行的状态更新。通过validate方法保证数据的一致性和正确性，而as_action方法则提供了将轨迹更新转换为动作的便利途径，使得不同的动力学模型能够在统一的框架下交互。

#traj->action #trajectory #update #waymax

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-02-11-dynamics_model = dynamics.StateDynamics() 为什么我要用state…

2024-02-11-dynamics_model = dynamics.StateDynamics() 为什么我要用state dynamics ? 难道就是因为我是全局坐标吗，我的action不管用？？

---

layout: post title: ‘dynamics_model = dynamics.StateDynamics() 为什么我要用state dynamics ? 难道就是因为我是全局坐标吗，我的action不管用？？ ‘ date: 2024-02-11T00:48:34-05:00

---

选择使用StateDynamics或其他动力学模型取决于你的仿真需求、动作的类型和你希望模型如何响应这些动作。StateDynamics是基于位置的模型，使用5D动作（x, y, yaw, velocity x, velocity y），这意味着它允许直接在全局坐标系中设置对象的状态。这种模型特别适用于以下情况：

1. 全局坐标系的直接控制

如果你的应用场景需要直接在全局坐标系中控制对象——例如，直接设定目标位置、朝向和速度，而不是通过相对移动或转向命令来控制——那么StateDynamics就非常适合。这在需要精确控制对象达到特定状态的仿真中特别有用。

2. 高级控制策略

在某些仿真中，你可能已经有了预计算的轨迹或者使用了某种高级的路径规划算法，这些算法直接输出目标的全局状态（位置、朝向和速度）。在这种情况下，使用StateDynamics可以直接应用这些高级控制策略的输出，而无需将它们转换为更低级的动作（如加速或转向）。

3. 简化动作到状态的映射

StateDynamics简化了动作到状态的映射关系，因为动作直接对应于状态的变化。这种直接映射有助于减少实现控制逻辑时的复杂性，尤其是在动作空间和状态空间较大的情况下。

4. 兼容性和灵活性

当你的仿真环境中有多个代理互动，且每个代理可能需要不同类型的动作时，StateDynamics提供了一种灵活的方式来统一动作接口。通过直接设置全局状态，不同类型的代理（如车辆、行人等）可以使用相同的动力学模型进行仿真，只要它们的动作可以被表述为全局状态的变化。

结论

使用StateDynamics的决定应基于你的具体应用需求。如果你的场景或控制策略需要直接在全局坐标系中控制对象的状态，或者你需要一个简化且直观的方式来实现复杂的控制逻辑，那么StateDynamics可能是一个合适的选择。然而，如果你的应用更侧重于模拟物理行为或需要考虑动作的可行性和物理约束，那么其他如DeltaLocal、DeltaGlobal或InvertibleBicycleModel等动力学模型可能更加适合。

#state_dynamics #5D #actions #waymax

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-02-10-怎么从log_trajt和sim_traj(t+1),推断t的action

---

layout: post title: ‘怎么从log_trajt和sim_traj(t+1),推断t的action ‘ date: 2024-02-10T21:17:22-05:00

---

在infer_expert_action函数中，目的是要从当前仿真轨迹（sim_traj）推断出将车辆从当前状态移动到下一个记录状态（log_traj[timestep + 1]）所需的动作。这个过程涉及到几个关键步骤，每一步都有其特定的原因和目的：

1. 提取当前和下一个状态

• prev_sim_traj: 通过simulator_state.sim_trajectory和 当前时间步simulator_state.timestep，这行代码提取了当前仿真轨迹的最后执行步骤，也就是车辆的当前状态。这代表了仿真中车辆的实时位置、朝向和可能还包括速度等信息。
• next_logged_traj: 类似地，通过simulator_state.log_trajectory和simulator_state.timestep + 1，这行代码提取了记录轨迹中的下一个状态。这代表了车辆应该达到的目标状态，通常是基于先前记录的数据。

2. 合并轨迹

• 合并操作: 使用jax.tree_map和jnp.concatenate将prev_sim_traj和next_logged_traj沿轨迹的时间维度合并。这个操作的目的是为了构建一个包含当前状态和目标状态的完整轨迹视图，从而为动力学模型的逆向函数提供输入。

3. 使用动力学模型推断动作

• 动力学模型逆向: 最后，dynamics_model.inverse方法被调用，以combined_traj（结合了当前和目标状态的轨迹）、metadata（车辆的元数据）和固定的时间步0（因为合并后的轨迹视为从当前到下一个状态的简单序列）作为输入，来推断必要的动作。这个动作是仿真中的车辆需要执行的，以便其状态从prev_sim_traj转变为next_logged_traj。

为什么要这么写？

• 精确控制和模拟: 这种方法允许精确地控制和模拟车辆从一个精确的当前状态移动到预期的下一个状态，特别是在仿真环境中进行自动驾驶算法的测试和验证时非常有用。
• 基于数据的决策: 通过比较当前仿真状态和记录的目标状态，可以更好地理解在特定情况下车辆应该如何响应，从而提高决策系统的准确性和可靠性。
• 优化学习和反馈: 这种从记录数据推断动作的策略，为算法提供了一个基于现实世界数据的优化目标，有助于改进和调整自动驾驶系统的性能。

总的来说，这种方法提供了一种结合当前仿真数据和历史记录数据，以数据驱动的方式进行精确决策和控制的策略，对于开发和测试高度可靠的自动驾驶系统至关重要。

#waymax #sim_traj #log_traj

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-02-10-sim——trajectory为什么和logged traj不是同一个。需要两个同时存在吗？

---

layout: post title: ‘sim——trajectory为什么和logged traj不是同一个。需要两个同时存在吗？ ‘ date: 2024-02-10T21:11:33-05:00

---

SimulatorState类包含仿真状态的信息，其中sim_trajectory和log_trajectory代表两种不同的轨迹数据。它们同时存在的原因与仿真的目的和过程密切相关。让我们逐一解析这些概念：

sim_trajectory（仿真轨迹）

• 定义：代表所有对象在仿真过程中的轨迹。这些轨迹是根据仿真模型和算法实时计算的，反映了在仿真环境中车辆的实际行驶路径。
• 用途：用来分析和评估仿真中的车辆行为，如决策系统的性能、路径规划的有效性等。
• 特点：未来的轨迹点（即还未被仿真模拟的部分）会被标记为无效，因为这些部分尚未发生，还在仿真的计算过程中。

log_trajectory（记录轨迹）

• 定义：代表所有对象的预先记录的轨迹。这些数据可能来自真实世界的观测，或者是在特定条件下预先模拟生成的。
• 用途：作为一个基准或参考，用来指导或评估仿真中车辆的期望行为。比如，可以用来训练和验证自动驾驶算法，确保仿真中的行为与“专家”或期望的行为一致。
• 特点：提供了一个明确的目标状态或行为模式，仿真算法需要尽量模拟或达到这些预先定义的轨迹。

为什么需要同时存在？

• 性能评估：通过比较sim_trajectory和log_trajectory，可以直观地评估仿真算法的性能，看看仿真中的车辆行为是否能够准确地复现记录的轨迹。
• 算法训练和验证：在自动驾驶系统的开发过程中，记录的轨迹（log_trajectory）提供了一个“真实”的行为标准，开发者可以用它来训练决策算法，然后通过仿真（sim_trajectory）来测试算法的效果。
• 仿真逼真度：保持这两种轨迹的区分，有助于提高仿真环境的逼真度和灵活性，使得仿真可以在多种条件和场景下进行，同时提供一个稳定的基准来评估变化的影响。

总之，sim_trajectory和log_trajectory的同时存在是为了在仿真环境中更好地模拟、评估和验证自动驾驶算法，使得开发者能够在安全的虚拟环境中精确地测试和改进车辆的行为和决策系统。

#sim_traj #log_traj #waymax

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-02-10-IDMRoutePolicy类继承自WaypointFollowingPolicy，这意味着它是一种特定…

2024-02-10-IDMRoutePolicy类继承自WaypointFollowingPolicy，这意味着它是一种特定的路径跟随策略。从类定义开始，理解每个参数的作用和意义： 那我是不是需要先去學習waypointfolloing policy呢

---

layout: post title: ‘IDMRoutePolicy类继承自WaypointFollowingPolicy，这意味着它是一种特定的路径跟随策略。从类定义开始，理解每个参数的作用和意义： 那我是不是需要先去學習waypointfolloing policy呢’ date: 2024-02-10T10:26:58-05:00

---

是的，了解WaypointFollowingPolicy类的基本原理和实现是理解IDMRoutePolicy类的良好起点。WaypointFollowingPolicy可能提供了一些基础的方法和属性，IDMRoutePolicy通过继承它们，可以在此基础上添加更具体的逻辑，例如应用智能驾驶员模型（IDM）来计算加速度和速度。

学习WaypointFollowingPolicy

在深入IDMRoutePolicy之前，了解WaypointFollowingPolicy涉及以下几个方面：

1. 基本概念：理解什么是路径跟随策略以及它是如何工作的。路径跟随通常涉及到根据一系列预定的路径点（或“航点”）来引导车辆行驶。

2. 属性和方法：检查WaypointFollowingPolicy类中定义的公共属性和方法，这些可能会被IDMRoutePolicy直接使用或重写。特别是，注意任何处理轨迹、更新车辆状态或计算下一步行动的方法。

3. 数据结构：了解WaypointFollowingPolicy处理的数据结构，如轨迹数据、车辆状态等。这些结构在IDMRoutePolicy中同样重要。

4. 继承和扩展：理解如何通过继承WaypointFollowingPolicy来创建新的策略类，并添加特定的行为（如IDM）。注意任何重写的方法或新增的属性，以及它们如何改变或增强基类的行为。

开始学习的方法

• 查看文档：如果有的话，阅读WaypointFollowingPolicy的官方文档或源代码注释，了解其设计意图和使用方式。

• 阅读源代码：直接阅读WaypointFollowingPolicy的源代码，理解其内部结构和实现细节。注重理解构造函数、关键方法的实现逻辑，以及如何处理输入输出数据。

• 实验和修改：在理解了基本结构后，可以尝试对WaypointFollowingPolicy进行一些简单的修改，或者创建一个基于它的简单子类，通过实际编码来加深理解。

• 查找示例：搜索是否有使用WaypointFollowingPolicy的示例或教程，实际的使用案例可以帮助你更快地理解它是如何工作的。

通过以上步骤，你将为深入理解和实现IDMRoutePolicy打下坚实的基础。掌握了WaypointFollowingPolicy的工作原理和方法后，理解它如何被扩展以实现IDM逻辑将会更加直观和简单。

#waypointFollowing #waymax #IDM

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-02-08-为什么明明modeled vehicle的轨迹会出现-1， -1呢。莫名其妙

---

layout: post title: ‘为什么明明modeled vehicle的轨迹会出现-1， -1呢。莫名其妙 ‘ date: 2024-02-08T16:17:13-05:00

---

在动态和复杂的环境中，如自动驾驶车辆的模拟和实际场景，-1作为填充值出现主要有几个原因：

1. 数据缺失：对于某一时间步，如果某个对象（如车辆、行人等）不在场景中或其数据未被记录，则可能会使用-1来表示该时间步的数据缺失。

2. 时间步骤不一致：在长时间序列数据中，不是所有对象在每个时间步都存在。例如，一个车辆可能在模拟开始时还没有出现，在结束前就已经离开了场景。为了保持数据的一致性和数组的形状，使用-1填充这些对象在不存在时的数据。

3. 数据预处理：在数据预处理阶段，-1可以用来标记未初始化或无效的数据点。这有助于后续处理阶段识别和过滤这些点。

4. 轨迹终止：对于动态对象，如模拟中的车辆，其轨迹可能在模拟结束前就已经终止（例如，车辆已经到达目的地）。在这种情况下，轨迹的剩余部分可能会用-1来填充。

由于你观察到modeled vehicle的轨迹中出现-1, -1，这表明在某些时间步，该车辆的位置数据不可用或不适用。处理这种情况的一种方法是在分析或可视化之前清除这些无效的数据点，确保只有有效且有意义的轨迹数据被使用。

在可视化或数据分析代码中，应当添加过滤条件来忽略这些-1值，例如，通过只选择X和Y坐标都不为-1的数据点来实现。这样可以确保得到的可视化结果或数据分析结果是基于实际有效的轨迹信息。

#-1的出现 #modeled_vehicle #wayamx #数据处理

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-02-07-我在Jupyter notebook上 怎麼看一個class所擁有的所有屬性或者method

---

layout: post title: ‘我在Jupyter notebook上 怎麼看一個class所擁有的所有屬性或者method’ date: 2024-02-07T11:08:21-05:00

---

在Jupyter Notebook中，你可以使用几种方法来查看一个类所拥有的所有属性或方法。以下是一些常用的技巧：

1. 使用dir()函数

dir()函数可以列出对象的所有属性和方法，包括魔术方法（以双下划线__开头和结尾的特殊方法）。

class MyClass:
    def __init__(self):
        self.attribute = "value"
    
    def my_method(self):
        pass

print(dir(MyClass))

这会列出MyClass类的所有属性和方法，包括Python的内置属性和方法。

2. 使用vars()函数或__dict__属性

对于实例化的对象，vars()函数或对象的__dict__属性可以显示对象的__dict__属性，其中包含了实例属性。

instance = MyClass()
print(vars(instance))
# 或者
print(instance.__dict__)

这将只显示实例的属性，不包括方法。

3. 使用内省（Introspection）工具

Jupyter Notebook支持使用问号?来查看对象的文档字符串，这对于快速获取类的信息很有用。

MyClass?

或者使用两个问号??来查看类的源代码（如果可用）：

MyClass??

4. 使用help()函数

help()函数可以打印出对象的帮助文档，包括类的文档字符串（如果有的话）以及类的所有属性和方法的简短描述。

help(MyClass)

这将提供比dir()更详细的信息，包括每个方法的签名和文档字符串。

5. 使用第三方库

还有一些第三方库，如ipython自身的%pinfo魔法命令，提供了更丰富的功能来探索对象：

%pinfo MyClass

以上方法可以帮助你在Jupyter Notebook中探索类的属性和方法。根据你的具体需求选择最适合的方法。

#class #python #attributes

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-02-06-為什麼title要寫在head裡面？ 而不是寫在html裡

面？ —

layout: post title: ‘為什麼title要寫在head裡面？ 而不是寫在html裡 面？’ date: 2024-02-06T12:25:24-05:00

---

<title> 標籤被放在 <head> 部分而不是直接放在 <html> 裡面，是因為 HTML 文檔的結構和標準規範。HTML 文檔分為兩大部分：<head> 和 <body>。這種結構設計反映了網頁內容的不同功能和角色：

<head> 部分

• 作用：包含文檔的元數據（metadata），這些信息是關於文檔的資訊，但不是直接顯示給最終用戶的內容。元數據包括字符集聲明、網頁標題、外部資源的鏈接（如樣式表、腳本文件等）和其他元信息（如作者、描述、關鍵詞等）。
• <title> 標籤的角色：<title> 標籤指定了網頁的標題，這個標題會顯示在瀏覽器的標籤條或標題欄上，並被搜索引擎用來識別網頁內容。因此，它是網頁元數據的一部分，自然應該放在 <head> 部分。

<body> 部分

• 作用：包含網頁的可見內容，即直接呈現給用戶的所有信息，包括文本、圖片、視頻、表格、互動元素等。
• 與 <title> 的關系：<body> 用於展示給用戶的內容，而 <title> 不屬於用戶直接在網頁內容區域看到的內容，因此 <title> 不放在 <body> 裡。

將 <title> 放在 <head> 裡面而不是 <body> 或直接在 <html> 裡面，是為了遵循 HTML 的結構規範，並且明確區分網頁的元數據與實際內容。這種結構化的設計使得瀏覽器和搜索引擎能夠更有效地解析和處理網頁資訊。

#html #body #head #titlle

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-02-06-html和java css python 的關係？

---

layout: post title: ‘html和java css python 的關係？’ date: 2024-02-06T12:23:25-05:00

---

HTML、JavaScript、CSS 和 Python 在網頁開發和設計中各自扮演著不同的角色，彼此之間關係密切但功能各異：

HTML (HyperText Markup Language)

• 角色：HTML 是網頁的骨架，負責結構的定義和內容的組織。它告訴瀏覽器如何顯示網頁上的文本、圖片以及其他內容。
• 關係：與 JavaScript 和 CSS 結合使用，HTML 提供網頁的基本結構，而 CSS 和 JavaScript 分別添加樣式和互動性。

CSS (Cascading Style Sheets)

• 角色：CSS 負責網頁的外觀和布局。它讓開發者能夠控制網頁的顏色、字體、間距、大小等視覺效果，從而提高用戶體驗。
• 關係：CSS 直接作用於 HTML 元素，改變它們的外觀。雖然它不是編程語言，但它是網頁設計不可或缺的部分。

JavaScript

• 角色：JavaScript 是一種腳本語言，用於在網頁上添加互動性。它可以改變 HTML 元素的內容、屬性，控制 CSS，並且處理用戶的事件（如點擊、滾動等）。
• 關係：JavaScript 與 HTML 和 CSS 一起工作，為靜態網頁添加動態功能。它可以直接嵌入 HTML 中，或作為獨立的文件引入。

Python

• 角色：Python 是一種高級編程語言，擁有豐富的庫和框架，如 Django 和 Flask，用於開發網頁後端（服務器端）應用。Python 負責處理網站的後端邏輯，包括資料庫交互、服務器配置、數據處理等。
• 關係：雖然 Python 主要用於網站的後端開發，但它也可以與 HTML、CSS 和 JavaScript 結合，通過生成動態 HTML 內容或通過 API 與前端交互，從而提供完整的網站解決方案。

總之，HTML、CSS 和 JavaScript 主要關注於網頁的前端（客戶端）部分，負責結構、樣式和功能；而 Python 通常用於後端開發，處理服務器、數據庫以及應用邏輯。這些技術一起協同工作，形成了現代網頁和網絡應用的基礎。

#css #java #html

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-01-27-dd

---

layout: post title: ‘dd’ date: 2024-01-27T16:48:05-05:00

---

Yancheng  

 在您提供的代码中，LSTM层、注意力机制层（Attention Layer），以及全连接层（Dense Layer）是按顺序连接的。这种设计有其特定的目的和原因，让我来逐一解释：

1. LSTM层：
   • 长短期记忆网络（LSTM）非常适合处理和预测时间序列数据，因为它们能够捕捉时间上的长距离依赖关系。LSTM通过其内部结构（包含遗忘门、输入门、和输出门）来决定在每个时间步保留和遗忘哪些信息。
   • 在序列处理任务中，如时间序列分析、自然语言处理等，LSTM层通常作为模型的一部分，用来处理序列输入并捕捉其中的时间动态。
2. 注意力机制层（SeqSelfAttention）：
   • 注意力机制允许模型在序列的不同部分分配不同的重要性，这有助于模型集中注意力于那些对当前任务更重要的信息上。
   • 在LSTM之后添加注意力层可以提高模型的性能，因为它使模型不仅能学习序列中的时间依赖性，还能学习到哪些部分的信息是在给定上下文中最重要的。
3. 全连接层（Dense）：
   • 全连接层通常用于神经网络的输出部分，将前面层的高级特征转换为最终的输出格式（例如，分类的类别或回归任务的数值预测）。
   • 在您的例子中，Dense层用于将经过LSTM和注意力处理的序列数据映射到预测目标上。这是一个普遍的做法，因为Dense层可以学习如何从复杂的特征表示中提取特定的任务相关输出。

这种层的组合（LSTM、注意力机制、Dense）在处理复杂序列数据时很有效，尤其是在需要模型理解长距离依赖并从中提取关键信息以做出预测的情况下。每一层都对输入数据的表示进行转换和细化，为最终的预测任务做准备。

#dd

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-01-27-ee

---

layout: post title: ‘ee’ date: 2024-01-27T16:45:41-05:00

---

Yancheng  

 在您提供的代码中，LSTM层、注意力机制层（Attention Layer），以及全连接层（Dense Layer）是按顺序连接的。这种设计有其特定的目的和原因，让我来逐一解释：

1. LSTM层：
   • 长短期记忆网络（LSTM）非常适合处理和预测时间序列数据，因为它们能够捕捉时间上的长距离依赖关系。LSTM通过其内部结构（包含遗忘门、输入门、和输出门）来决定在每个时间步保留和遗忘哪些信息。
   • 在序列处理任务中，如时间序列分析、自然语言处理等，LSTM层通常作为模型的一部分，用来处理序列输入并捕捉其中的时间动态。
2. 注意力机制层（SeqSelfAttention）：
   • 注意力机制允许模型在序列的不同部分分配不同的重要性，这有助于模型集中注意力于那些对当前任务更重要的信息上。
   • 在LSTM之后添加注意力层可以提高模型的性能，因为它使模型不仅能学习序列中的时间依赖性，还能学习到哪些部分的信息是在给定上下文中最重要的。
3. 全连接层（Dense）：
   • 全连接层通常用于神经网络的输出部分，将前面层的高级特征转换为最终的输出格式（例如，分类的类别或回归任务的数值预测）。
   • 在您的例子中，Dense层用于将经过LSTM和注意力处理的序列数据映射到预测目标上。这是一个普遍的做法，因为Dense层可以学习如何从复杂的特征表示中提取特定的任务相关输出。

这种层的组合（LSTM、注意力机制、Dense）在处理复杂序列数据时很有效，尤其是在需要模型理解长距离依赖并从中提取关键信息以做出预测的情况下。每一层都对输入数据的表示进行转换和细化，为最终的预测任务做准备。

#ee

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-01-27-ss

---

layout: post title: ‘ss’ date: 2024-01-27T16:43:37-05:00

---

Yancheng  

 在您提供的代码中，LSTM层、注意力机制层（Attention Layer），以及全连接层（Dense Layer）是按顺序连接的。这种设计有其特定的目的和原因，让我来逐一解释：

1. LSTM层：
   • 长短期记忆网络（LSTM）非常适合处理和预测时间序列数据，因为它们能够捕捉时间上的长距离依赖关系。LSTM通过其内部结构（包含遗忘门、输入门、和输出门）来决定在每个时间步保留和遗忘哪些信息。
   • 在序列处理任务中，如时间序列分析、自然语言处理等，LSTM层通常作为模型的一部分，用来处理序列输入并捕捉其中的时间动态。
2. 注意力机制层（SeqSelfAttention）：
   • 注意力机制允许模型在序列的不同部分分配不同的重要性，这有助于模型集中注意力于那些对当前任务更重要的信息上。
   • 在LSTM之后添加注意力层可以提高模型的性能，因为它使模型不仅能学习序列中的时间依赖性，还能学习到哪些部分的信息是在给定上下文中最重要的。
3. 全连接层（Dense）：
   • 全连接层通常用于神经网络的输出部分，将前面层的高级特征转换为最终的输出格式（例如，分类的类别或回归任务的数值预测）。
   • 在您的例子中，Dense层用于将经过LSTM和注意力处理的序列数据映射到预测目标上。这是一个普遍的做法，因为Dense层可以学习如何从复杂的特征表示中提取特定的任务相关输出。

这种层的组合（LSTM、注意力机制、Dense）在处理复杂序列数据时很有效，尤其是在需要模型理解长距离依赖并从中提取关键信息以做出预测的情况下。每一层都对输入数据的表示进行转换和细化，为最终的预测任务做准备。

#ss

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

haha

#ss

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-01-27-ceshi

---

layout: post title: ‘ceshi’ date: 2024-01-27T16:42:18-05:00

---

在您提供的代码中，LSTM层、注意力机制层（Attention Layer），以及全连接层（Dense Layer）是按顺序连接的。这种设计有其特定的目的和原因，让我来逐一解释：

1. LSTM层：
   • 长短期记忆网络（LSTM）非常适合处理和预测时间序列数据，因为它们能够捕捉时间上的长距离依赖关系。LSTM通过其内部结构（包含遗忘门、输入门、和输出门）来决定在每个时间步保留和遗忘哪些信息。
   • 在序列处理任务中，如时间序列分析、自然语言处理等，LSTM层通常作为模型的一部分，用来处理序列输入并捕捉其中的时间动态。
2. 注意力机制层（SeqSelfAttention）：
   • 注意力机制允许模型在序列的不同部分分配不同的重要性，这有助于模型集中注意力于那些对当前任务更重要的信息上。
   • 在LSTM之后添加注意力层可以提高模型的性能，因为它使模型不仅能学习序列中的时间依赖性，还能学习到哪些部分的信息是在给定上下文中最重要的。
3. 全连接层（Dense）：
   • 全连接层通常用于神经网络的输出部分，将前面层的高级特征转换为最终的输出格式（例如，分类的类别或回归任务的数值预测）。
   • 在您的例子中，Dense层用于将经过LSTM和注意力处理的序列数据映射到预测目标上。这是一个普遍的做法，因为Dense层可以学习如何从复杂的特征表示中提取特定的任务相关输出。

这种层的组合（LSTM、注意力机制、Dense）在处理复杂序列数据时很有效，尤其是在需要模型理解长距离依赖并从中提取关键信息以做出预测的情况下。每一层都对输入数据的表示进行转换和细化，为最终的预测任务做准备。

#ceshi

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2024-01-27-為什麼要在每一層的code是這樣聯結的呢？ LSTM , attention DENSE

---

layout: post title: ‘為什麼要在每一層的code是這樣聯結的呢？ LSTM , attention DENSE ‘ date: 2024-01-27T16:40:56-05:00

---

在您提供的代码中，LSTM层、注意力机制层（Attention Layer），以及全连接层（Dense Layer）是按顺序连接的。这种设计有其特定的目的和原因，让我来逐一解释：

1. LSTM层：
   • 长短期记忆网络（LSTM）非常适合处理和预测时间序列数据，因为它们能够捕捉时间上的长距离依赖关系。LSTM通过其内部结构（包含遗忘门、输入门、和输出门）来决定在每个时间步保留和遗忘哪些信息。
   • 在序列处理任务中，如时间序列分析、自然语言处理等，LSTM层通常作为模型的一部分，用来处理序列输入并捕捉其中的时间动态。
2. 注意力机制层（SeqSelfAttention）：
   • 注意力机制允许模型在序列的不同部分分配不同的重要性，这有助于模型集中注意力于那些对当前任务更重要的信息上。
   • 在LSTM之后添加注意力层可以提高模型的性能，因为它使模型不仅能学习序列中的时间依赖性，还能学习到哪些部分的信息是在给定上下文中最重要的。
3. 全连接层（Dense）：
   • 全连接层通常用于神经网络的输出部分，将前面层的高级特征转换为最终的输出格式（例如，分类的类别或回归任务的数值预测）。
   • 在您的例子中，Dense层用于将经过LSTM和注意力处理的序列数据映射到预测目标上。这是一个普遍的做法，因为Dense层可以学习如何从复杂的特征表示中提取特定的任务相关输出。

这种层的组合（LSTM、注意力机制、Dense）在处理复杂序列数据时很有效，尤其是在需要模型理解长距离依赖并从中提取关键信息以做出预测的情况下。每一层都对输入数据的表示进行转换和细化，为最终的预测任务做准备。

#lstm #Attention #Dense #self_attention #layer

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-28-利用lstm model 更新policy 裡面的speed

---

layout: post title: ‘利用lstm model 更新policy 裡面的speed’ date: 2023-10-28T20:07:27-04:00

---

def update_speed(
    self, state: datatypes.SimulatorState, dt: float = 0.1
) -> tuple[jax.Array, jax.Array]:
    # 假设 lstm_model.predict_speed 返回预测的速度
    speeds = self._lstm_model.predict_speed(state)
    valids = jnp.ones(state.shape + (state.num_objects,), dtype=jnp.bool_)
    return (speeds, valids)

#lstm #waymax #policy

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-27-為什麼shape縮小了呢，原來不是三個維度嗎，現在怎麼變2維度了

---

layout: post title: ‘為什麼shape縮小了呢，原來不是三個維度嗎，現在怎麼變2維度了’ date: 2023-10-27T16:58:12-04:00

---

数组的形状减小是因为您的切片操作选择了特定的数据而没有保留所有的维度。具体来说：

1. 在第一个维度上，您选择了前两个元素（即 x 和 y 变量），所以这个维度的大小从 6 减小到 2。
2. 在第二个维度上，您选择了索引为 1 的单个对象，而没有保留对象维度。当您在某个维度上指定一个具体的索引时（例如 1），那个维度就会被消除，不会出现在结果数组中。这就是为什么结果数组只有两个维度而不是三个。
3. 在第三个维度上，您选择了前五个时间步，所以这个维度的大小从 num_timesteps 减小到 5。

综上所述，通过指定第二维度的具体索引（1），您消除了一个维度，从而将数组从三维减少到了二维。这也是为什么结果数组的形状是 (2, 5)，而不是 (2, 1, 5)。如果您想保留对象维度，可以使用 None 或 np.newaxis 来添加一个新的维度，例如 data[:2, 1:2, :5] 或 data[:2, 1, :5][..., np.newaxis, :]，这样结果数组的形状就会是 (2, 1, 5)。

data[:2, 1, :5][…, jnp.newaxis, :].shape 沒懂這句話 為什麼可以這麼寫

在NumPy和Jax中，np.newaxis 或 None 用于在数组中添加一个新的轴（维度）。np.newaxis 和 None 在这方面是等效的。当你在数组切片时使用 np.newaxis 或 None，它会添加一个额外的维度，该维度的大小为1。这通常用于改变数组的维度，使其符合某些操作的需要。

在你的例子中，data[:2, 1, :5] 产生一个形状为 (2, 5) 的二维数组。然后，[..., jnp.newaxis, :] 是一个切片操作，它在最后一个维度之前插入一个新的维度。... 是一个省略号，它表示所有前面的维度，jnp.newaxis 插入一个新的维度，而 : 保留最后一个维度。

现在，让我们分解 [..., jnp.newaxis, :]：

1. ...（省略号）代表所有现有的维度，即 (2, 5)。
2. jnp.newaxis 在现有维度之间插入一个新的维度，改变形状为 (2, 1, 5)。
3. : 保留最后一个维度不变。

最终结果是一个形状为 (2, 1, 5) 的三维数组。

以下是这个操作的代码示例：

import jax.numpy as jnp

# Assuming data is your original array
subset = data[:2, 1, :5]
new_subset = subset[..., jnp.newaxis, :]

print(new_subset.shape)  # Output: (2, 1, 5)

通过这种方式，你可以在数组中插入新的维度，以满足你的需求。

#shape #newaxis #slicing

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-27-jnp.stack([x, y, vx, vy, yaw, acc, valid, length, width…

2023-10-27-jnp.stack([x, y, vx, vy, yaw, acc, valid, length, width, height], axis=0) 這一步。我不能理解你是怎麼把(num_objects, num_timesteps) 類型的數據堆疊起來的，最後的shape還是我給妳要求的shape形狀嗎？ （10， num_obj, num_time_step）?

---

layout: post title: ‘jnp.stack([x, y, vx, vy, yaw, acc, valid, length, width, height], axis=0) 這一步。我不能理解你是怎麼把(num_objects, num_timesteps) 類型的數據堆疊起來的，最後的shape還是我給妳要求的shape形狀嗎？ （10， num_obj, num_time_step）?’ date: 2023-10-27T16:37:26-04:00

---

是的，当你使用jnp.stack函数并指定axis=0时，你会得到一个形状为(10, num_objects, num_timesteps)的数组。jnp.stack函数是用来沿着新轴连接数组的，这意味着它会创建一个新的维度来容纳所有要堆叠的数组。

在你提供的代码中，jnp.stack函数接收了一个包含10个数组的列表，并且你指定了axis=0，所以它会在新创建的维度上堆叠这些数组。每个数组的形状都是(num_objects, num_timesteps)，所以最终的数组的形状会是(10, num_objects, num_timesteps)。

以下是一个简单的例子来解释jnp.stack是如何工作的：

import jax.numpy as jnp

# 假设有三个形状为(2, 3)的数组
a = jnp.array([[1, 2, 3], [4, 5, 6]])
b = jnp.array([[7, 8, 9], [10, 11, 12]])
c = jnp.array([[13, 14, 15], [16, 17, 18]])

# 使用jnp.stack并指定axis=0来堆叠这些数组
stacked_array = jnp.stack([a, b, c], axis=0)

# 输出堆叠后的数组的形状
print(stacked_array.shape)  # 输出: (3, 2, 3)

在这个例子中，你可以看到我们得到了一个新的数组，其形状为(3, 2, 3)。这与你的情况非常相似，只是你有10个数组而不是3个数组。

#jax #stack #axis=0 #shape

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-27-用于指示场景中与对象张量的第一维度相对应的哪些对象具有交互式行为。最多可以选择2个对象。此列表中的对象形成…

2023-10-27-用于指示场景中与对象张量的第一维度相对应的哪些对象具有交互式行为。最多可以选择2个对象。此列表中的对象形成了一个交互组。啥意思呢？self.ids.shape， tuple[int, …]:？？？

---

layout: post title: ‘用于指示场景中与对象张量的第一维度相对应的哪些对象具有交互式行为。最多可以选择2个对象。此列表中的对象形成了一个交互组。啥意思呢？self.ids.shape， tuple[int, …]:？？？’ date: 2023-10-27T14:47:08-04:00

---

1. objects_of_interest:
   • objects_of_interest 是一个布尔向量，它的目的是标识场景中的特定对象，这些对象具有交互性或特定的行为，可能需要特别注意或处理。例如，在一个交通模拟中，可能有一些对象（如车辆或行人）的行为是可以交互的，或者与其他对象的交互可能会影响模拟的结果。布尔向量中的每个元素对应于场景中的一个对象，如果元素的值为 True，则表示该对象是交互式的，并应包含在交互组中。根据描述，最多可以有2个对象被选为交互对象，这可能是由于模拟的限制或其他原因。
2. shape 方法:
   • shape 方法返回一个元组，该元组描述了 ids 属性的形状。在Python中，tuple 是一个可以存储不同类型数据的容器，[int, ...] 表示这个元组包含一个或多个整数。在这种情况下，self.ids.shape 是一个描述 ids 数组形状的元组，例如，如果 ids 是一个2D数组，其形状为 (5, 3)，则 shape 方法将返回 (5, 3)。

这些属性和方法提供了有关模拟中对象和其元数据的重要信息，这对于理解模拟的工作方式和构建强化学习模型可能是非常有用的。在处理这种复杂的模拟时，理解元数据的结构和含义是非常重要的。

#metadata #waymax #ROI

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-26-分析waymaxactor和expert的model的流程

---

layout: post title: ‘分析waymaxactor和expert的model的流程’ date: 2023-10-26T21:03:45-04:00

---

好的，让我们按照刚才讨论的顺序来逐步分析这几个类。

1. WaymaxActorCore 类:

• 目的: 这个类的目的是定义一个接口，为在模拟环境中执行推断的角色提供功能。
• 主要方法和属性:
  • init 方法: 初始化角色的内部状态。它返回一个 ActorState 对象，该对象可以包含任何需要在下一次调用中传递的信息。
  • select_action 方法: 根据当前的模拟器状态选择一个动作。它返回一个 WaymaxActorOutput 对象，该对象包含下一个动作和角色状态。
  • name 属性: 返回角色的名称，用于检查和记录。

2. SimAgentActor 类:

• 继承: 继承自 WaymaxActorCore 类。
• 目的: 为模拟代理提供基础，主要用于产生轨迹更新。
• 主要方法和属性:
  • update_trajectory 方法: 一个抽象方法，需要在子类中实现。它负责更新所有模拟代理的轨迹。
  • select_action 方法: 重写了基类的 select_action 方法，调用 update_trajectory 方法获取下一个轨迹更新，并将其转换为一个动作。

3. WaypointFollowingPolicy 类:

• 继承: 继承自 SimAgentActor 类。
• 目的: 定义如何按照指定的路点更新代理的轨迹和速度。
• 主要方法和属性:
  • update_trajectory 方法: 实现了 SimAgentActor 类中定义的抽象方法，负责计算并返回模拟代理的下一个轨迹。
  • update_speed 方法: 一个抽象方法，需要在子类中实现。它负责计算每个模拟步骤中每个代理的速度。

4. IDMRoutePolicy 类:

• 继承: 继承自 WaypointFollowingPolicy 类。
• 目的: 提供基于智能驾驶模型 (IDM) 的策略来更新速度和轨迹。
• 主要方法和属性:
  • update_speed 方法: 实现了 WaypointFollowingPolicy 类中定义的抽象方法，使用 IDM 来计算加速度和速度。

通过这个逐步的分析，你可以看到每个类是如何构建在前一个类的基础上的，以及每个类是如何扩展和实现更具体功能的。从基类到子类，功能变得越来越具体，而接口保持一致。这使得代码结构清晰，易于理解和维护。

#waymax #waypointFollowing #policy #RL #IDM

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-26-沒懂Hashable 啥意思。 還是有aux data

---

layout: post title: ‘沒懂Hashable 啥意思。 還是有aux data ‘ date: 2023-10-26T21:01:46-04:00

---

理解Hashable和aux data的概念是重要的，让我们逐一解释：

1. Hashable:
   • 在Python中，Hashable是指一个对象有一个固定的哈希值，这个哈希值在该对象的生命周期内不会改变。具有这种属性的对象可以用作字典的键或者添加到集合中。通常，不可变对象（如整数、浮点数、字符串、元组等）是可哈希的，而可变对象（如列表、字典等）是不可哈希的。
   • 举例来说，字符串和元组是可哈希的，因为它们的哈希值在创建后不会改变，而列表和字典是不可哈希的，因为它们的内容可以改变，从而改变它们的哈希值。

# Example of hashable objects
my_string = "hello"
my_tuple = (1, 2, 3)

# These objects can be used as dictionary keys
my_dict = {my_string: "value1", my_tuple: "value2"}

# Example of non-hashable objects
my_list = [1, 2, 3]
my_dict2 = {my_list: "value"}  # This will raise a TypeError because lists are not hashable

1. Auxiliary Data (aux data):
   • 辅助数据（auxiliary data）通常是指与主要数据相关，但不是主要数据本身的数据。它可以包含任何额外的信息，可能对处理主要数据有帮助。
   • 在register_pytree_node函数的上下文中，辅助数据是flatten_func返回的第二个元素，它可能包含了与子节点无关，但对unflatten_func重构原始对象有用的信息。
   • 例如，辅助数据可能包括原始对象的元数据，如对象的类型、大小或其他属性。在unflatten_func中，这些辅助数据可以用于确保正确地重构原始对象。

这两个概念是从Python编程和register_pytree_node函数的文档中得来的，帮助我们理解如何实现和使用unflatten_func函数。

#hash #Auxdata

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-26-道路的點數據（道路/紅綠燈等）怎麼利用

---

layout: post title: ‘道路的點數據（道路/紅綠燈等）怎麼利用’ date: 2023-10-26T04:15:22-04:00

---

确实，利用点数据可以以多种方式构建和理解道路网络。以下是一些可能的想法和方法来处理和利用这些数据：

1. 创建道路网络图:
   • 你可以创建一个图结构来表示道路网络，其中节点表示路点，边表示道路段。这种图结构可以帮助理解道路网络的拓扑结构，并可以用于诸如路径查找或交通流模拟等任务。
2. 空间编码:
   • 你可以考虑使用一些空间编码技术来捕捉道路网络的几何和拓扑信息。例如，使用图卷积网络（GCN）或其他空间编码方法来处理点数据和其空间关系。
3. 生成张量表示:
   • 为了将数据输入到LSTM或其他神经网络中，你可能需要创建一个张量表示。这可能包括创建一个多通道的图像或张量，其中每个通道代表不同类型的道路特征（例如车道、交通信号等）。
4. 时间序列分析:
   • 如果你有关于交通流或车辆运动的时间序列数据，可以与路点数据结合来创建一个时间空间数据集。这可以用于训练LSTM等模型来分析和预测交通流量和其他时间相关的目标。
5. 特征工程:
   • 你可以基于点数据和其他可用信息创建一些有用的特征。例如，计算道路的曲率、交叉口的密度、交通信号的位置等。
6. 聚类和区域分析:
   • 通过聚类分析，可以识别交叉路口、圆形交通和其他重要的道路结构。这可以帮助理解道路网络的布局，并可能有助于识别交通瓶颈和其他问题区域。
7. 交通模拟:
   • 你可以使用点数据和其他道路信息来创建交通模拟，以理解交通流的动态，并可能预测不同条件下的交通流量。

以上方法和想法可能需要一些数据处理和分析技能，以及对交通工程和机器学习的理解。通过结合这些技术和方法，你可以开始探索如何利用你的点数据来理解和分析道路网络和交通流量。

#featureengineering #spacecoding #vector #聚類區域分析

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-26-waymo dataset 數據類型

---

layout: post title: ‘waymo dataset 數據類型 ‘ date: 2023-10-26T03:44:32-04:00

---

https://waymo.com/open/data/motion/tfexample

#waymo #wamax #roadgraph #trafficsign

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

New Note 



https://arxiv.org/pdf/2310.08710.pdf 

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-21-waymax install

---

layout: post title: ‘waymax install ‘ date: 2023-10-21T23:25:20-04:00

---

Nvidiadriver : 525(from) 我寫了一個jupyter的安裝連結在github(waymax)

Cuda ; 11.8 Cudnn 8.6 Tensor sort : 8.+ Linux 20.04(22不行。不支持tensors?)

Jan (install second hard version for cuda 11) Waymax (install from github)

【ubuntu20.04系统4060安装cuda11.8和cudnn8.6 - CSDN App】http://t.csdnimg.cn/uvn7f

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-22-类型注解是什麼

---

layout: post title: ‘类型注解是什麼’ date: 2023-10-22T20:42:16-04:00

---

类型注解（Type Annotations）是 Python 3.5 引入的一项功能，允许开发者为变量、函数参数和函数返回值指定预期的数据类型。类型注解可以帮助开发者和工具更好地理解代码，并可以通过类型检查器（如 Mypy）来发现类型错误和其他潜在问题。

下面是一些类型注解的示例：

1. 变量类型注解：

   name: str = "Alice"
   age: int = 25
   

2. 函数参数和返回值类型注解：

   def greet(name: str) -> str:
    return f"Hello, {name}!"
   

3. 列表和字典类型注解（需要从 typing 模块导入 List 和 Dict，或在 Python 3.9+ 中直接使用 list 和 dict）： ```python from typing import List, Dict # Python 3.5 - 3.8

   或在 Python 3.9+ 中:

   list[int] 和 dict[str, int]

numbers: List[int] = [1, 2, 3] info: Dict[str, int] = {“age”: 25}

4. **自定义类类型注解**：
```python
class Person:
    def __init__(self, name: str, age: int):
        self.name = name
        self.age = age

def get_age(person: Person) -> int:
    return person.age

类型注解的好处包括：

• 提高代码可读性：类型注解明确了变量和函数的预期类型，使得代码更易于理解。
• 发现错误：通过使用类型检查器，如 Mypy，你可以在运行代码之前发现类型错误和其他潜在问题。
• 支持 IDE 和工具：许多 IDE 和工具使用类型注解提供更好的代码补全、提示和分析。
• 文档和自描述：类型注解可以作为代码文档的一部分，明确函数和模块的接口和用法。

虽然类型注解是可选的，但它们是一种很好的实践，可以帮助保持代码的清晰和健壮。

#類型註解 #-> #python39

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-22-你說的src test都有init .py 他是用來幹什麼的

---

layout: post title: ‘你說的src test都有init .py 他是用來幹什麼的’ date: 2023-10-22T20:30:20-04:00

---

__init__.py 文件是 Python 包的一部分，它的存在使得 Python 将目录识别为包（一个模块的集合）。这个文件可以为空，但必须存在于包目录中，以便 Python 可以正确地导入包中的模块。

以下是 __init__.py 文件的一些用途和作用：

1. 包初始化：
   • 当导入包时，__init__.py 文件会被自动执行。你可以在这个文件中放置初始化代码，例如设置包级变量或运行初始化函数。
2. 导入控制：
   • 通过在 __init__.py 文件中指定 __all__ 列表，你可以控制 from <package> import * 时哪些模块被导入。

# 在 __init__.py 文件中
__all__ = ["module1", "module2"]

1. 方便导入：
   • 你可以在 __init__.py 文件中导入包中的模块，以便外部代码可以更方便地访问它们。

# 在 __init__.py 文件中
from . import module1
from . import module2

1. 包的组织和结构：
   • __init__.py 文件有助于保持包的组织结构，明确哪些目录包含 Python 代码，哪些不包含。
2. 包版本和元数据：
   • 你可以在 __init__.py 文件中定义包的版本号、作者信息等元数据。

# 在 __init__.py 文件中
__version__ = "1.0.0"

在你的项目中，src 和 tests 目录下的 __init__.py 文件可以是空的，但它们的存在使得你可以将 src 和 tests 作为包来使用，并在其他地方导入它们的模块。例如，你可以在 main.py 文件中导入 src.vehicle 和 src.simulator 模块。

#代碼結構 #包級模塊__init__py

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-22-# 使用 for 循环迭代 simulator1 对象

for value in simulator1: print(value) # 输出: 0 1 2 為啥simulator 不是數據，還可以for ？ 最後他但因出來的value有是什麼呢？ —

layout: post title: ‘# 使用 for 循环迭代 simulator1 对象 for value in simulator1: print(value) # 输出: 0 1 2 為啥simulator 不是數據，還可以for ？ 最後他但因出來的value有是什麼呢？’ date: 2023-10-22T19:39:34-04:00

---

在Python中，一个对象能否被用于 for 循环，取决于它是否实现了迭代协议，而不是它是否看起来像一个数据集合。迭代协议由两个方法组成：__iter__() 和 __next__()。如果一个对象的类定义了这两个方法，那么这个对象就可以被用于 for 循环。

1. 为什么 simulator1 可以用于 for 循环？
   • 在你提供的代码中，Simulator 类实现了 __iter__() 和 __next__() 方法，所以 simulator1 实例是可迭代的，并且可以被用于 for 循环。
2. for 循环是如何工作的？
   • 当你使用 for 循环遍历 simulator1 时，Python首先会调用 simulator1.__iter__() 方法来获取一个迭代器对象。在这个例子中，__iter__() 方法返回 self，所以 simulator1 本身就是迭代器。
   • 然后，Python会在每次循环迭代中调用 __next__() 方法来获取下一个值。__next__() 方法的返回值会被赋给循环变量 value，并在循环体中使用。
3. value 是什么？
   • 在循环的每次迭代中，value 变量会被设置为 __next__() 方法的返回值。在你提供的 Simulator 类的例子中，__next__() 方法返回当前的 self.current 值，并将 self.current 值加1，以便于下次迭代。

class Simulator:
    def __init__(self, start, end):
        self.current = start
        self.end = end

    def __iter__(self):
        return self

    def __next__(self):
        if self.current < self.end:
            value = self.current
            self.current += 1
            return value
        else:
            raise StopIteration

simulator1 = Simulator(0, 3)

for value in simulator1:
    print(value)  # 输出: 0 1 2

在上述代码的 for 循环中，value 会依次被设置为 0, 1, 和 2，因为 __next__() 方法在每次迭代时返回 self.current 的值，并将 self.current 值加1。

#simulator #iterator #iter #next #python

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-22-iter __next__這種寫法，在python上是不是約定俗成的，如果要讓一個class變的…

2023-10-22-iter __next__這種寫法，在python上是不是約定俗成的，如果要讓一個class變的是可以迭代的，就必須要寫成這.iter 永遠都是return sel. next 永遠都是實際上用來控制每個迭代的邏輯的？

---

layout: post title: ‘iter __next__這種寫法，在python上是不是約定俗成的，如果要讓一個class變的是可以迭代的，就必須要寫成這.iter 永遠都是return sel. next 永遠都是實際上用來控制每個迭代的邏輯的？’ date: 2023-10-22T19:21:04-04:00

---

是的，你的理解是正确的。在Python中，__iter__()和__next__()方法是约定俗成的方法，用于使一个对象成为可迭代的（iterable）和创建迭代器（iterator）。这些方法为Python的迭代协议（iteration protocol）提供支持，该协议定义了对象应如何在循环中进行迭代。

1. __iter__() 方法:
   • __iter__()方法应返回一个迭代器对象，该对象必须实现__next__()方法。通常，如果类自身就是迭代器，__iter__()方法会返回self。
2. __next__() 方法:
   • __next__()方法应返回序列中的下一个值。当序列中没有更多的值时，应抛出StopIteration异常来结束迭代。

这是Python的一个基本协议，它允许对象支持for循环和其他迭代上下文。通过实现这两个方法，你可以控制迭代过程，定义在每个步骤中应该发生什么。

以下是一个简单的例子，显示了如何使用__iter__()和__next__()方法来创建一个简单的计数器迭代器：

class Counter:
    def __init__(self, limit):
        self.limit = limit
        self.count = 0

    def __iter__(self):
        return self  # 返回迭代器对象本身

    def __next__(self):
        if self.count < self.limit:
            value = self.count
            self.count += 1
            return value
        else:
            raise StopIteration  # 结束迭代

# 使用for循环迭代Counter对象
for i in Counter(3):
    print(i)  # 输出: 0 1 2

在这个例子中，Counter类实现了__iter__()和__next__()方法，使其实例成为可迭代的。__iter__()方法返回self，表示Counter实例本身就是一个迭代器。__next__()方法控制了迭代过程，每次调用时返回下一个值，直到计数器达到指定的限制，然后抛出StopIteration异常来结束迭代。

#iter #nex #simulator #iterable #self #python

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-22-為什麼simple decorator 的參數fn, 並沒有被當作參數船東給wrapped. , wrapped…

2023-10-22-為什麼simple decorator 的參數fn, 並沒有被當作參數船東給wrapped. , wrapped卻可以執行關於他的操作，進行調用？

---

layout: post title: ‘為什麼simple decorator 的參數fn, 並沒有被當作參數船東給wrapped. , wrapped卻可以執行關於他的操作，進行調用？’ date: 2023-10-22T18:55:36-04:00

---

这涉及到Python的一个重要概念：闭包（Closure）。闭包允许一个函数记住其外部作用域的值，即使这个作用域已经退出执行。在我们的装饰器例子中，wrapped函数就是一个闭包。

来分析一下为什么wrapped可以使用fn，即使我们没有将fn作为参数传递给它：

1. 定义时的作用域：当我们定义wrapped函数时，它位于simple_decorator函数的内部。这意味着wrapped可以访问它外部的任何变量，其中就包括fn。

2. 闭包的记忆能力：即使simple_decorator函数执行完毕，wrapped仍然可以“记住”fn是什么。这是因为wrapped被定义为一个闭包，它“捕获”了外部变量fn的引用。

3. 调用wrapped时的行为：当我们最终调用wrapped时（例如通过装饰器后的函数调用），wrapped会使用它所记忆的fn。这就是为什么我们可以在wrapped内部直接调用fn()，而不需要将fn作为参数传递给wrapped。

为了进一步说明这一点，考虑以下示例：

def outer_function(x):
    def inner_function(y):
        return x + y
    return inner_function

closure = outer_function(10)
print(closure(5))  # 输出：15

在上面的代码中，当我们调用outer_function(10)时，它返回了inner_function。然后我们将这个返回的函数赋值给变量closure。当我们调用closure(5)时，它实际上是调用inner_function(5)，并且使用了outer_function的x值（即10）。这就是闭包的工作原理：即使outer_function已经执行完毕，inner_function仍然记得x的值。

在装饰器的情况下，同样的原理适用。wrapped函数记住了fn的值，因此可以在其内部调用fn()，无需将其作为参数传递。

#python #decorator

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-20-windows登陸linux ， xrdp

---

layout: post title: ‘windows登陸linux ， xrdp ‘ date: 2023-10-20T03:15:37-04:00

---

反正记住一句话，重启后不在本地登录，那么远程必不黑屏！

#xrdp #linux #remotedesktop

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

3 min - proposal updated 可以提交了。 10+5 3 min through thesis + 7 min explain what changes I make. And the reason for that . Deadline - check November . 1.要發送文件給老師— （ppt） 2.submit peer 5. 還有一個啥事兒 要上moodle去看 6.

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-19-我如果把模型替換成lstm預測的模型，或者考慮加速度。這樣對比的研究。

---

layout: post title: ‘我如果把模型替換成lstm預測的模型，或者考慮加速度。這樣對比的研究。’ date: 2023-10-19T07:26:51-04:00

---

使用LSTM预测模型或考虑加速度确实可能会使对碰撞时间（TTC）的预测更准确。下面是这种方法可能的意义和好处：

1. 更准确的预测:
   • 简单模型通常假设车辆将继续以当前速度运行，而不会改变方向或速度。这种模型可能会低估碰撞的可能性，特别是在交通繁忙的情况下。
   • LSTM模型可以学习交通流的时间依赖性，从而更好地预测每辆车的未来轨迹。这可能会导致更准确的TTC估计。
2. 理解复杂交通模式:
   • 通过使用LSTM或其他时间序列分析模型，可以捕获交通流中的复杂模式和依赖关系，这可能有助于理解交通流如何随时间变化，以及何时和何地最可能发生碰撞。
3. 性能评估:
   • 比较简单模型和LSTM模型的性能可能会揭示更复杂模型是否值得投资。如果LSTM模型能够显著提高TTC预测的准确性，那么这种更复杂的方法可能是值得的。
4. 实时应用:
   • 在实时交通监控和无人驾驶系统中，准确的TTC预测是非常重要的。通过比较简单模型和LSTM模型，可以确定哪种方法更适合实时应用。
5. 策略和规划:
   • 更准确的TTC预测可以用于交通规划和优化，例如，通过调整交通信号定时或提供给驾驶员的实时交通建议来减少碰撞风险。

在实施LSTM模型或考虑加速度时，可能需要考虑一些因素，例如数据的可用性和质量，以及计算资源。同时，应该通过交叉验证和其他评估方法来评估不同模型的性能，并确保所选模型能够在实际应用中提供准确可靠的预测。

#ttc #lstm

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-19-辆速度和加速度分析:

通过车辆的轨迹数据，可以计算车辆的速度和加速度，了解交通流的动态。 怎麼計算，你可以在我剛給你的代碼中實現嗎 —

layout: post title: ‘辆速度和加速度分析: 通过车辆的轨迹数据，可以计算车辆的速度和加速度，了解交通流的动态。 怎麼計算，你可以在我剛給你的代碼中實現嗎’ date: 2023-10-19T06:54:37-04:00

---

要计算车辆的速度和加速度，你需要知道车辆在不同时间点的位置。速度是位置随时间的变化率，而加速度是速度随时间的变化率。在离散的时间点，这些可以通过以下公式计算：

1. 速度计算: [ v(t) = \frac{d(t) - d(t - \Delta t)}{\Delta t} ]
   • ( v(t) ) 是在时间 ( t ) 的速度。
   • ( d(t) ) 和 ( d(t - \Delta t) ) 是在时间 ( t ) 和 ( t - \Delta t ) 的位置。
   • ( \Delta t ) 是两个时间点之间的时间差。
2. 加速度计算: [ a(t) = \frac{v(t) - v(t - \Delta t)}{\Delta t} ]
   • ( a(t) ) 是在时间 ( t ) 的加速度。
   • ( v(t) ) 和 ( v(t - \Delta t) ) 是在时间 ( t ) 和 ( t - \Delta t ) 的速度。
   • ( \Delta t ) 是两个时间点之间的时间差。

在你提供的代码中，可以通过车辆在连续帧之间的位置变化来估算速度和加速度。请注意，速度和加速度的计算依赖于准确的时间戳和空间尺度，这可能需要额外的信息或假设。

以下是一个基于你提供的代码的简单示例，用于计算速度和加速度。假设每帧之间的时间间隔是固定的，并且你有一个合适的空间尺度因子来将像素距离转换为实际距离。

class VelocityAccelerationCalculator:
    def __init__(self):
        self.previous_positions = {}  # 记录上一帧的位置
        self.previous_velocities = {}  # 记录上一帧的速度

    def calculate(self, vehicle_id, position, frame_delta_time):
        # 计算速度和加速度
        velocity = None
        acceleration = None

        if vehicle_id in self.previous_positions:
            # 计算速度
            delta_position = position - self.previous_positions[vehicle_id]
            velocity = delta_position / frame_delta_time

            if vehicle_id in self.previous_velocities:
                # 计算加速度
                delta_velocity = velocity - self.previous_velocities[vehicle_id]
                acceleration = delta_velocity / frame_delta_time

        # 更新上一帧的位置和速度
        self.previous_positions[vehicle_id] = position
        self.previous_velocities[vehicle_id] = velocity

        return velocity, acceleration

# 创建速度和加速度计算器实例
velocity_acceleration_calculator = VelocityAccelerationCalculator()

# ... 其他代码 ...

# 在你的callback函数中
def callback(frame: np.ndarray, index:int) -> np.ndarray:
    # ... 其他代码 ...

    for detection_idx in range(len(detections)):
        vehicle_id = int(detections.tracker_id[detection_idx])
        xy = trace_annotator.trace.get(tracker_id=vehicle_id)  # 获取轨迹点

        # 假设每帧之间的时间间隔是1/30秒
        frame_delta_time = 1 / 30

        # 计算速度和加速度
        velocity, acceleration = velocity_acceleration_calculator.calculate(vehicle_id, xy[-1], frame_delta_time)

        # ... 其他代码 ...

    # ... 其他代码 ...

在这个示例中，我们创建了一个 VelocityAccelerationCalculator 类，它可以存储上一帧的位置和速度。在你的 callback 函数中，我们调用 VelocityAccelerationCalculator 的 calculate 方法来计算每个检测到的车辆的速度和加速度。这只是一个基本的示例，并且可能需要根据你的具体情况进行调整。

#trafficanalysis

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-19-我獲取到了在紅綠燈控制的交叉路口，所有車輛，包括車輛類型的軌跡，我能做什麼呢？

---

layout: post title: ‘我獲取到了在紅綠燈控制的交叉路口，所有車輛，包括車輛類型的軌跡，我能做什麼呢？’ date: 2023-10-19T06:53:26-04:00

---

利用交通交叉口的车辆轨迹数据，您可以进行许多有趣和有用的分析和应用。下面是一些可能的方向：

1. 交通流量分析:
   • 了解不同时间段的交通流量，例如高峰时段和非高峰时段的流量差异。
   • 分析不同车辆类型（例如汽车、卡车和公共汽车）的流量。
2. 交通安全分析:
   • 识别可能的危险驾驶行为，例如过速、急刹或急转弯。
   • 分析交通事故，了解事故发生的原因并提出改善建议。
3. 交通信号优化:
   • 根据交通流量数据优化红绿灯的时间设置，以减少拥堵和等待时间。
   • 实时调整交通信号以适应交通条件。
4. 基础设施规划和优化:
   • 识别交通拥堵点和需要改善的区域。
   • 提供数据支持，以便城市规划者做出更好的交通基础设施决策。
5. 车辆速度和加速度分析:
   • 通过车辆的轨迹数据，可以计算车辆的速度和加速度，了解交通流的动态。
6. 行为模式识别:
   • 通过分析车辆轨迹，可以识别特定的交通模式和行为，例如车流合并和分离、交通拥堵模式等。
7. 实时交通监控和预警系统:
   • 开发实时交通监控系统，对异常交通事件（例如交通事故或交通拥堵）进行实时监控和预警。
8. 数据可视化和报告:
   • 创建交通流量和安全的可视化报告，为政策制定者和公众提供信息。
9. 车辆轨迹数据的商业应用:
   • 如广告定位、交通状况预测服务、和交通管理系统等。
10. 研究和学术分析:
    • 使用交通数据进行科学研究，比如交通流理论、驾驶行为分析等。
11. 模拟和预测:
    • 使用历史数据进行交通模拟和预测，以了解不同交通管理策略的影响。

通过对车辆轨迹数据的深入分析和利用，您可以为交通管理、城市规划和交通安全做出有益的贡献。同时，这也为您提供了探索交通学、数据科学和机器学习等领域的机会。

#trajectory #intersection #trafficanalysis

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

現在用car+brake訓練的模型不錯。 繼續吧vehicle type加進去class訓練 Traffic light 數據庫不對，要重新找。但是現在需要吧vehicle type / brake light 合併訓練。等看結果，如果滿意。繼續訓練traffic light 數據庫。需要添加class

⁃	1我已經吧merged_label ，改為了label
⁃	把train valid .test 原來的label備份到另根目錄文件夾。以後訓練可以參考。
⁃	模型大概11 am 訓練結束 明天把drone dataset處理後拿到的csv文件進行preprocessing然後，用lstm 分析預測。然後要重點想與交通相關的分析，要量化整個結果。整合論文。

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-18-怎麼把兩個模型對同一個image的的檢測的txt合併。一個在label s文件夾，一個在labels_new…

2023-10-18-怎麼把兩個模型對同一個image的的檢測的txt合併。一個在label s文件夾，一個在labels_new文件夾。 他們的class ID都是一致的。

---

layout: post title: ‘怎麼把兩個模型對同一個image的的檢測的txt合併。一個在label s文件夾，一個在labels_new文件夾。 他們的class ID都是一致的。’ date: 2023-10-18T19:48:01-04:00

---

为了合并两个模型的检测结果，你可以通过读取每个模型产生的文本文件，然后将它们合并到一个新的文本文件中。在下面的代码示例中，我们首先遍历 labels 和 labels_new 目录下的所有文本文件，然后将每个文件的内容合并到一个新的文本文件中，该文件将保存在一个名为 merged_labels 的新目录中。

import os
from pathlib import Path

def merge_labels(data_dir):
    # 创建一个新的目录来保存合并后的标签文件
    merged_dir = Path(f'{data_dir}/merged_labels')
    merged_dir.mkdir(exist_ok=True)
    
    # 定义原始标签目录和新标签目录的路径
    original_label_dir = Path(f'{data_dir}/labels')
    new_label_dir = Path(f'{data_dir}/labels_new')
    
    # 获取原始标签目录和新标签目录中的所有文件
    original_files = set(file.stem for file in original_label_dir.glob('*.txt'))
    new_files = set(file.stem for file in new_label_dir.glob('*.txt'))
    
    # 确保两个目录中的文件名是匹配的
    assert original_files == new_files, "File names in the label directories do not match"
    
    # 遍历每个文件
    for file_name in original_files:
        original_file_path = original_label_dir / f'{file_name}.txt'
        new_file_path = new_label_dir / f'{file_name}.txt'
        merged_file_path = merged_dir / f'{file_name}.txt'
        
        # 读取原始标签文件和新标签文件的内容
        with open(original_file_path, 'r') as original_file, \
             open(new_file_path, 'r') as new_file, \
             open(merged_file_path, 'w') as merged_file:
                 
            # 将原始标签文件的内容写入合并后的标签文件
            merged_file.write(original_file.read())
            
            # 将新标签文件的内容写入合并后的标签文件
            merged_file.write(new_file.read())

if __name__ == '__main__':
    # 定义数据目录
    data_dirs = ['train', 'test', 'valid']
    
    # 对每个数据目录执行合并操作
    for data_dir in data_dirs:
        merge_labels(data_dir)

在这段代码中，我们创建了一个名为 merge_labels 的函数，该函数接受一个表示数据目录（例如 train、test 或 valid）的参数。我们首先创建了一个名为 merged_labels 的新目录，然后定义了原始标签目录和新标签目录的路径。我们获取了两个目录中的所有文件名，并确保它们是匹配的。然后，我们遍历了每个文件，读取了原始标签文件和新标签文件的内容，并将它们合并到一个新的标签文件中，该文件保存在 merged_labels 目录中。

#yolov8 #模型合併 #class合併

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-18-利用模型yolovx.pt檢測車輛類型，最後保存到標籤txt格式。

---

layout: post title: ‘利用模型yolovx.pt檢測車輛類型，最後保存到標籤txt格式。’ date: 2023-10-18T19:27:20-04:00

---

https://docs.ultralytics.com/modes/predict/#boxes

好的，根据您的要求，我为您提供了一段代码。该代码将遍历指定的 train/images, test/images, 和 valid/images 目录，使用模型进行预测，并将预测结果保存到对应的 train/labels_new, test/labels_new, 和 valid/labels_new 目录中。

import os
from ultralytics import YOLO
from pathlib import Path

# Load a model
if __name__ == '__main__':
    model = YOLO('yolov8x.pt')  # load a pretrained model

    # Define the directories
    data_dirs = ['train', 'test', 'valid']
    
    for data_dir in data_dirs:
        # Create labels_new directories if they don't exist
        os.makedirs(f'{data_dir}/labels_new', exist_ok=True)
        
        # Define the image directory
        image_dir = Path(f'{data_dir}/images')
        
        # Iterate through all the images in the image directory
        for image_path in image_dir.glob('*.jpg'):  # Assuming images are in jpg format
            # Get the prediction results
            results = model(str(image_path), save_txt=True)
            
            # Iterate through the results and save them to the labels_new directory
            for i, result in enumerate(results):
                txt_output_dir = Path(f'{data_dir}/labels_new') / f'{image_path.stem}_{i}.txt'
                result.save_txt(txt_output_dir)

在这段代码中：

1. 我们首先加载了预训练的模型 yolov8x.pt。
2. 定义了一个包含 train, test, 和 valid 的列表 data_dirs，以便遍历这些目录。
3. 对于每个 data_dir，我们创建一个 labels_new 子目录（如果它不存在），然后定义图像目录 image_dir。
4. 遍历 image_dir 中的所有 .jpg 图像文件，获取预测结果。
5. 遍历预测结果，并将每个结果保存到 labels_new 目录下的文本文件中。每个文本文件的名称基于原始图像文件的名称和预测结果的索引。

#yolov8 #txt #利用模型進行labeling

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

明天重新吧train dataset的images（特別是traffic light）那一塊的 重新標記（因為只標記了紅綠燈，導致… 明天重新吧train dataset的images（特別是traffic light）那一塊的 重新標記（因為只標記了紅綠燈，導致v

1.導致檢測不出來vehicle 。新的模型可以在舊的模型的基礎上進行訓練。 2.另一個研究思路（針對某一區域/路段/進行檢測。看看師傅駕駛行為有異常？）

2。區域性的檢測（in out 學習怎麼實現的）

5.	畫的軌跡圖，vehicle的moving方向+ 速度一起訓練
15.	研究的目的是要探測 aggressive lane changing behaviour 
23.	想像怎麼結合到co-simulation裡面
34.	重新訓練一個只探測紅綠燈的/或者看看有沒有類似的模型
73.	我現在把車輛煞車燈和車輛檢測的數據結合在一起了。是在txt裡，直接吧所有檢測出來煞車和沒煞車都改成了car的標籤。但問題是他不能探測不同的車輛類型。所以以後可能需要在數據庫裏增加車輛type的檢測。
108.	用yolovx.ptj檢測現在的taillight的數據庫。然後可以得到車輛的標籤和class type了。然後把這個檢測出來的txt跟原來的txt合併/應該就可以了。

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-18-比較好的數據庫 taillight 韓國國民大學

---

layout: post title: ‘比較好的數據庫 taillight 韓國國民大學’ date: 2023-10-18T16:32:47-04:00

---

https://universe.roboflow.com/kookmin-university-glfyz/state-of-vehicle-tail-lamp-detection/model/2

#dataset #taillight #roboflow

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-18-是的，根据代码中的逻辑，只有当车辆经过这些预定义的多边形区域时，它们才会被识别和计数。这些区域是通过 ZONE_IN_POLYGONS…

2023-10-18-是的，根据代码中的逻辑，只有当车辆经过这些预定义的多边形区域时，它们才会被识别和计数。这些区域是通过 ZONE_IN_POLYGONS 和 ZONE_OUT_POLYGONS 变量定义的。代码通过检查对象的边界框是否与这些多边形区域相交来确定对象是否进入或离开了这些区域。

在 process_frame 方法中，代码将检测到的对象与每个区域进行比较，并记录那些进入或离开区域的对象。这些信息随后由 DetectionsManager 类的 update 方法用于更新进入和离开各区域的对象计数。 沒理解 —

layout: post title: ‘是的，根据代码中的逻辑，只有当车辆经过这些预定义的多边形区域时，它们才会被识别和计数。这些区域是通过 ZONE_IN_POLYGONS 和 ZONE_OUT_POLYGONS 变量定义的。代码通过检查对象的边界框是否与这些多边形区域相交来确定对象是否进入或离开了这些区域。

在 process_frame 方法中，代码将检测到的对象与每个区域进行比较，并记录那些进入或离开区域的对象。这些信息随后由 DetectionsManager 类的 update 方法用于更新进入和离开各区域的对象计数。 沒理解’ date: 2023-10-18T05:45:57-04:00

---

从代码中可以看出，该程序旨在分析视频中的交通流量，特别是检测和跟踪通过特定区域的车辆。这些区域通过ZONE_IN_POLYGONS和ZONE_OUT_POLYGONS变量以多边形的形式定义。代码逻辑的一部分如下：

1. 多边形区域的定义：
   • ZONE_IN_POLYGONS和ZONE_OUT_POLYGONS分别定义了一组进入区域和离开区域的多边形。每个多边形都是由一系列的点定义，这些点构成了多边形的边缘。
2. 检测和跟踪：
   • 使用 YOLOv8 对视频帧进行车辆检测，并使用 ByteTrack 进行对象跟踪。这样可以在视频帧序列中跟踪每辆车的运动。
3. 区域交叉检查：
   • 代码检查每个检测到的对象（在这种情况下是车辆）是否与定义的进入或离开区域相交。这是通过process_frame方法实现的，该方法比较每个检测对象与每个多边形区域，并确定哪些对象正在进入或离开这些区域。
4. 更新和计数：
   • DetectionsManager类的update方法负责更新和管理通过各个区域的车辆计数。它维护了一个字典，该字典跟踪了每个跟踪器ID与区域ID之间的关系，以及每个区域的进入和离开计数。

通过这种方式，代码能够识别和计数通过特定多边形区域的车辆，以及他们是在进入还是离开这些区域。然后，它将这些信息注释到输出视频中，以便用户可以可视化交通流量和各区域的车辆计数。

#counting #tracking #polygon #detection #yolov8

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-18-區域counting vehicle

---

layout: post title: ‘區域counting vehicle ‘ date: 2023-10-18T05:45:35-04:00

---

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-18-本地查看模型訓練的進度tensorboard

---

layout: post title: ‘本地查看模型訓練的進度tensorboard’ date: 2023-10-18T03:56:45-04:00

---

命令 tensorboard –logdir=—runs bind_all

192.168.1.100:6006/#scalars&runSelectionState=eyJkZXRlY3RcXHRyYWluOCI6dHJ1ZSwiZGV0ZWN0XFx0cmFpbjkiOnRydWUsImRldGVjdFxcdHJhaW4xMCI6dHJ1ZSwiZGV0ZWN0XFx0cmFpbjExIjp0cnVlLCJkZXRlY3RcXHRyYWluMTIiOnRydWUsImRldGVjdFxcdHJhaW4xMyI6dHJ1ZSwiZGV0ZWN0XFx0cmFpbjE0Ijp0cnVlfQ%3D%3D

#tensorboard #localnetwork #VPN

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-18-我的訓練設置

---

layout: post title: ‘我的訓練設置’ date: 2023-10-18T03:13:55-04:00

---

from ultralytics import YOLO import torch

torch.cuda.set_device(0, 1)

Load a model

if name == ‘main’: model = YOLO(‘yolov8x.pt’) # load a pretrained model (recommended for training) # model = YOLO(‘yolov8n.yaml’).load(‘yolov8n.pt’) # build from YAML and transfer weights model.to(‘cuda’) print(“will using GPU for training.”) # Train the model results = model.train(data=’combined.yaml’, imgsz=640, batch=64, epochs=100, device=[0, 1], workers=40)

C:\Users\Xingnan Zhou>nvidia-smi Wed Oct 18 03:14:40 2023 +—————————————————————————————+

NVIDIA-SMI 537.58 Driver Version: 537.58 CUDA Version: 12.2

—————————————–+———————-+———————-+

GPU Name TCC/WDDM

Bus-Id Disp.A

Volatile Uncorr. ECC

Fan Temp Perf Pwr:Usage/Cap

Memory-Usage

GPU-Util Compute M.

MIG M.

=========================================+======================+======================

0 NVIDIA RTX A5000 WDDM

00000000:01:00.0 Off

Off

80% 87C P2 205W / 230W

24187MiB / 24564MiB

98% Default

N/A

+—————————————–+———————-+———————-+

1 NVIDIA RTX A5000 WDDM

00000000:05:00.0 Off

Off

66% 87C P2 177W / 230W

23894MiB / 24564MiB

99% Default

N/A

我的training數據總數： 7358 images,】 Test : 955 Validation : 2006

#training #multiplegpu #setting #worker #batchsize #epochs

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Hello Professor. Thank you for taking the time to meet with me. I…

Hello Professor. Thank you for taking the time to meet with me. I would like to discuss the reviewer feedback on my paper and my latest research progress with you.

[Discussion on Reviewer Feedback]

Firstly, regarding the paper I submitted to the journal, the reviewers provided some valuable feedback, focusing mainly on the following aspects:

1. Methodology and Results Presentation: They felt the presentation of methodology and the breadth of results were more akin to a tutorial rather than a research article.
2. Formatting and Organizational Structure: For instance, the lack of side numbering and the clarity of some visual presentations were pointed out.
3. Undefined and Unclear Terms: The reviewers believed that some terms and statements were not sufficiently explained or defined.

I am revising my paper based on these feedback, but at the same time, I am also wondering if you have any other journals or conferences to recommend, as well as the specific requirements for graduation. Due to family pressure, I hope to publish the paper and graduate as soon as possible.

[Research Progress]

Secondly, I would like to update you on my latest progress on detection vehicle braking, and traffic light . So far, I have processed 400 two-minute video files, successfully obtaining the trajectories, vehicle categories, and brake light , traffic light statuses of the . My next step is to continue developing a model to study traffic pattern detection., patterns was uploaded into teams folder , I plan to write this part of the research into another paper, and also include it in my thesis. Another steps , I am currently making an app on iOS that can record videos and gps data and transfer it directly to my server in realtime: which can help us enlarge the dataset without purchasing any new devices.

[Seeking Professor’s Opinions and Suggestions]

I am very much looking forward to hearing your opinions and suggestions to ensure my research and paper revisions are heading in the right direction. Also, I would like to understand the specific requirements for graduation and your views on my current research progress.

[Thank You]

Thank you very much for your time and insights, Professor. I am thrilled to have your guidance to ensure the successful completion of my research project and thesis.

-how to address : Based on your abstract and the earlier mentioned feedback from reviewers, it seems that the methodology part of your research might require further clarification and elaboration. Here are some suggestions on what you might consider modifying or adding to address the concerns:

1. Clarify Methodology:
   • Describe how you integrated VISSIM and CARLA, and how these two tools interact with each other. For instance, explain how data is transferred from one platform to the other, and how this integration is achieved.
   • Provide detailed explanations on how you employed deep learning algorithms to simulate autonomous vehicle behaviors, including what algorithms were used, and how they were trained and validated.
2. Provide More Practical Scenarios:
   • Incorporate more real-world traffic scenarios and use cases to demonstrate the broad applicability and practical value of your Co-Simulation framework.
3. Quantitative Analysis:
   • Offer more quantitative analysis, such as showcasing the performance differences between autonomous and conventional vehicles under different traffic conditions through charts, graphs, or data tables.
4. Enhance Results Presentation:
   • Provide more specific examples based on your research findings to illustrate how autonomous vehicles can improve traffic safety and reduce the risk of road accidents.
5. Reference Relevant Research:
   • Reference related research and literature to support your methodology and conclusions, especially the latest advancements in deep learning algorithms and traffic simulation.
6. Clear Steps and Flowcharts:
   • Provide clear steps and flowcharts to explain your research methods and process, allowing readers to better understand your research framework and implementation.
7. Extend Experiments:
   • If possible, consider conducting more experiments to validate the effectiveness and performance of your framework and methods under different scenarios and conditions.

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-17-TRB評審意見

---

layout: post title: ‘TRB評審意見’ date: 2023-10-17T13:57:11-04:00

---

Reviewer 1: Overall the topic is interesting but the paper, while identifying the research gap, does not provide a methodological approach nor a set of results wide enough to justify publication as it is. What the paper provides is a set of specifications for the used tools, which give it more a tutorial-like structure. For a journal publication, I would encourage the authors to widen the analyzed scenarios and the methodological approach used.

Comments:

• The format of the paper is lacking the numbering on the side. Pag. 6 - figure 1: Is figure 1 really necessary? Pag.6 - step 1: the sentence breaks before “direction angles, etc.” Pag.6 - steps: I would suggest to widen figure 1 to convey all the steps thar right now are listed, to make this part clearer. Pag.6 Paragraph 10: Right now the steps do not constitute an algorithm but rather just a list of steps. Pag.6 paragraph 11: “the information from VISSIM, including the following categories, will be…” -> which categories. Pag.6 paragraph 11: Please expand the algorithm description, to discuss less the list of steps and more the information flow at each simulation time step. Is the data exchanged the one in table 1? If so, it is not clear. Pag. 8: I see here figure 2 is the more detailed version of what I would suggest to have as figure 1 (an algorithm structure with the generic simulation steps and information exchange). So this picture does not solve my previous comment. About figure 2 itself, Please increase the character size and consider color coding the boxes in different clusters (right now it is very difficult to understand the picture without going through each single box). Pag. 9: At this point I wonder if the description of the two models should be shortened to two small sections and then a bigger section should be dedicated at the architecture. The CARLA simulator section starts now but CARLA has already been heavily referenced in the VISSIM section and in figure 2. Pag. 9 - Roadrunner steps: I am not sure it is worth to report in a scientific paper how to export some files or libraries. These sections so far felt like a technical tutorial while I would have expected a methodological section here. Pag. 19 figure 13: This picture does not convey anything and its quality is very low. Pag. 19 figure 15: This picture’s quality is very low. Pag. 20 point 2: “leading to the following behavior” but no following behavior is described. Is it meant the passage from flee flow to car-following behavior? If so it is not clear. Pag.20 paragraph 7: But isn’t this mathematical model simply overfitting over the simulation results? In the end you obtain a probability distribution that reproduces reliably only this model and is not transferable at all. Pag. 20 last paragraph: Is there any reference or theoretical background for the choice of an exponential function? Or is it an hypothesis? Pag. 21 figure 16: Please plot the results instead of copy pasting the model prompt. Pag. 21 last paragraph: The dissertation so far focuses so much on the tools and so little on the methodology behind it, that I would not present these results as anything more than an applicative example. You do state the limitations in the previous paragraph but then pivot to present the results as valuable insight into the safety performance of CAV. I would try to reframe the paper to enhance the methodological contribution, since as you state the experiment has various simplifications that make the results less than representative.

Reviewer 3: The scope, method and results of the paper are difficult to follow. The type of AV considered is not defined. Results are not clearly described and highlighted. Unclear statements e.g. “Clearly define the criteria for conflicts and accidents, such as minimum safe distance or minimum relative velocity.” and “convert TTC values to probabilities representing the likelihood of accidents occurring when CAV and Conv vehicles interact.” without references on how that can be done.

There is a lot of repetition of redundant parts, but the important parts (scope, aim, method, results) are not clear enough. The text is partly very unclear and it is not clear what the authors aim to say. The purpose and method of the cloning are not explained, nor what type of AV is considered.

Many of the figures are redundant screenshots from various programs. What is the value of Table 1? Some figures are difficult to read and not sufficiently explained (eg Fig 14).

Bold statements are made without references or justification.

Comments related to specific sections:

Introduction

   - Questionable claims are made without explanation, e.g. “Tesla and Waymo are the leading companies in the self-driving car industry” - according to which criteria? It is questionable whether Tesla’s Level 2 systems should be called self-driving.    - The CoExist project ended in 2020, so past tense should be used.    - The paragraph starting “In the CoExist project, the PreScan software..” is not clear. Terms are used without explanations or context.

Paragraph starting “The first problem is..”    - References needed for claims like 8GB of data a day    - A bold claim like “This data is indispensable to the operational safety of the vehicle and the roadway as a whole (5).” should be backed with a more neutral source than a stakeholder company report.

Paragraph starting “The second problem is..”    - “efforts have not been given to incorporating a complete microscopic traffic simulation software”: unclear statement, where should traffic simulation be incorporated? What is a complete microscopic traffic simulation software? Ways exist to include V2X messages in microscopic traffic simulations.    - “Mature simulation software can reproduce the operational patterns of traffic flow and has a positive impact on congestion prediction as well as traffic safety.”  How can traffic simulation have an impact on congestion prediction or traffic safety?

References are needed, e.g. for the claim “For the development of self-driving vehicles, the use of computer simulation for self-driving vehicle algorithms will become the most popular method for safety testing in the future. The simulation and real physical tests will form a mutually integrated organic whole, and one cannot be without the other.”

Unclear terms such as    -  ”the algorithm” (which algorithm?) in “Some open-source software packages, such as CARLA(Car Learning to Act), provide comprehensive APIs that enable developers to modify the algorithm easily”    - “Since VISSIM allows users to develop secondary development and supports the development of interfaces with other applications, the development of Co-Simulation based on VISSIM can effectively    reduce the development and learning costs.” What secondary development?

Vissim simulator    - “Instead of using 5G transmission, the intersection or highway camera data can be directly collected by the Co-Simulation framework’s vehicle detection, counting, and speed detection module.” What is the context? What does the camera data refer to?    - What is the “safety and efficiency module of the Co-Simulation”?    

Co-Simulation    - “This makes up for the fact that existing traffic simulation    software does not have sensor models, cannot support 3D information input, and has a simple physical collision model.” Most traffic microsimulations do not allow collisions to happen.

Scenario test road build-up    - “The study area include a tesing track, which is a closed loop consisting of one-way lanes.” What was the reason for choosing this kind of track/road?    - “In this experiment, the expert example trajectory sample set is collected by driving on the customized experimental road loop with the rule-based programming of Autopilot Mode built into the CARLA platform, and the expert strategy dataset collects a total of 4 hours of data containing about 14400 frames of driving information. Each frame of information Contains the vehicle’s trajectory.” This description is very unclear. What is the driving behaviour of the vehicle? Is it a Vissim default human-driven car, or some kind of AV model?    - The text talks about behaviour cloning, but gives no context as to what kind of behaviour is cloned, and why.    - “If it is, the detection vehicle is considered a possible dangerous target, and the WARNING message will alert.” Whom will it alert? what happens after the message is received?    - Basics are missing: How many vehicles are there? What is the share of AVs? What is the speed limit? Is it a 1-lane road (difficult to see from the figure)?    

Analysis of conflicts and accident risks in mixed traffic with CAV and CONV

   - “The length of the area is 200 meters, and the speed distribution is set to 1km/h-3km/h.” This means that the vehicles are driving at speeds of 1 to 3 km/h? If so, what kind of situation in real traffic does this represent?    Or does it mean that the speeds between vehicles differ by up to 3 km/h?            - “The research results indicate that when the following vehicle is a CAV, the collision probability is approximately 0.54. On the other hand, when the next vehicle is a ConV, the collision probability is approximately 0.72.”    How did you reach these results? Is it an average of all trials?    What do these values tell us - That the probabilities for a crash are 54%/72%? If so, the studied scenarios must have been very risky in the first place?

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-17-我拿到了車輛運動軌跡的pattern .然後訓練一個模型用它來識別交通衝突。可行嗎？ 那我的benchmark…

2023-10-17-我拿到了車輛運動軌跡的pattern .然後訓練一個模型用它來識別交通衝突。可行嗎？ 那我的benchmark是什麼呢

---

layout: post title: ‘我拿到了車輛運動軌跡的pattern .然後訓練一個模型用它來識別交通衝突。可行嗎？ 那我的benchmark是什麼呢’ date: 2023-10-17T13:29:18-04:00

---

利用车辆运动轨迹的模式来识别交通冲突是一种可行的方法，这种方法通常被称为交通冲突分析或交通冲突检测。通过分析车辆的运动轨迹和相互间的交互，可以识别出可能导致事故的情况。在实施这种方法时，您可以考虑以下几点：

1. 数据准备：
   • 首先，您需要有足够的数据来训练和验证您的模型。这些数据应包括车辆的运动轨迹以及标记的交通冲突事件。
2. 特征工程：
   • 对于车辆的运动轨迹，您可能需要提取有意义的特征，如速度、加速度、转向角、车辆间的相对距离和相对速度等。
3. 模型选择：
   • 选择一个适合的机器学习或深度学习模型来处理这种类型的问题。常用的模型包括时间序列分析模型、循环神经网络（RNN）、卷积神经网络（CNN）或其他适用于序列数据的模型。
4. 模型训练与验证：
   • 使用您的数据来训练模型，并通过交叉验证或其他方法来验证模型的性能。
5. 模型评估：
   • 评估模型的性能，包括但不限于精度、召回率、F1分数和AUC-ROC曲线等。

关于benchmark，它通常是指在模型开发和评估过程中使用的参考标准或基线。它可以是以下几种形式：

1. 现有模型的性能：
   • 如果市面上已经有类似功能的模型，那么这些模型的性能可以作为benchmark。
2. 人类专家的表现：
   • 如果可能，人类专家的表现也可以作为一个benchmark。
3. 随机或简单模型的表现：
   • 例如，随机猜测或使用简单规则的模型的表现。
4. 业界标准数据集上的表现：
   • 如果有公认的标准数据集和评估协议，那么在这些数据集上的表现也可以作为benchmark。

有了明确的benchmark，您可以更好地评估您的模型的性能，了解模型的优势和局限，并在此基础上进行进一步的优化和改进。

#benchmark #traffic #pattern

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-17-traffic light detection dataset

---

layout: post title: ‘traffic light detection dataset ‘ date: 2023-10-17T03:09:00-04:00

---

https://universe.roboflow.com/signal-sense-traffic-signal-detection/traffic-signals- mcmpm/dataset/16

https://universe.roboflow.com/fyp-wrdsh/road-signs-and-traffic-lights-dataset/browse?queryText=&pageSize=50&startingIndex=0&browseQuery=true

#trafficlight

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-17-tqdm

---

1. 使用tqdm库： 如果想要一个更美观的进度条，可以使用tqdm库。首先，你需要安装tqdm： bash

Copy code pip install tqdm 然后可以这样使用它： python

Copy code from tqdm import tqdm

def batch_process(video_folder, output_video_folder, output_csv_folder): os.makedirs(output_video_folder, exist_ok=True) os.makedirs(output_csv_folder, exist_ok=True)

for video_file in tqdm(os.listdir(video_folder)):
    # ... 其他代码 ... tqdm会为os.listdir(video_folder)循环创建一个可视化的进度条，显示你的代码处理进度。 #tqdm #批量處理

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-17-multiple gpu handling

---

layout: post title: ‘multiple gpu handling ‘ date: 2023-10-17T01:29:37-04:00

---

import torch

torch.cuda.set_device(0) # 对于code1.py

或者

torch.cuda.set_device(1) # 对于code2.py

在Windows环境下，你可以使用一个批处理文件（.bat）来达到类似的目的。以下是步骤：

1. 使用文本编辑器（如Notepad或VS Code）创建一个新文件。
2. 将以下代码复制并粘贴到该文件中：

    SET CUDA_VISIBLE_DEVICES=0
    start python code1.py
   
    SET CUDA_VISIBLE_DEVICES=1
    start python code2.py
   

3. 保存文件为run_scripts.bat（确保文件扩展名为.bat）。
4. 双击run_scripts.bat文件，或在命令提示符中导航到该文件的目录并运行run_scripts.bat。

start命令将使每个Python脚本在其自己的新窗口中运行。SET CUDA_VISIBLE_DEVICES命令是用来指定每个脚本应该使用哪个GPU。

请注意，这种方法的一个限制是，SET CUDA_VISIBLE_DEVICES可能不会像在Linux下那样工作，因为它是为Unix-like系统设计的。在Windows中，你可能需要使用其他方法来指定GPU设备，例如在Python代码中使用PyTorch的torch.cuda.set_device()函数。

如果你的代码确实基于PyTorch，你可以在code1.py和code2.py中分别添加以下行来指定要使用的GPU：

import torch

torch.cuda.set_device(0)  # 对于code1.py

# 或者

torch.cuda.set_device(1)  # 对于code2.py

在这种情况下，你的run_scripts.bat文件只需包含以下行：

start python code1.py
start python code2.py

#multiplegpu #torch #windowsbatch

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

avoid text book lecturing

1. Methodology - is to explain why method I choose is a good fit to my Data. Can d repeatability
   1. 並不是所有的基礎的方法都不行。如果特別合適。可以用。也並不是所有的最新的方法都能，如果不fit，就算了
   2. 最後部分的討論-必須要跟results你得到的，直接相關。
   3. abstract不能太寬了，要narrow。如果太specific，也不行。
   4. Discussion -可以引用methodology的產生的圖片，然後重點針對ROI。如果我們改變某一個parameter。或者線的走向。
   5. 可以討論under a specific condition(traffic), 交通現象越來越重。類似的結論。（也就是說result是圖片，但是討論部分要更近一步，）
   6. limitations。
   7. Keeping records。但是每次在分析數據的時候的時候，要記錄下來。可以記錄下來，data出來的時候，有什麼缺點。要把點連成線。不要等到最後才寫。
   8. 如果reviewer說了什麼，你要儘量專業的改。如果有哪改不了的。如果改不了，可以證明哈不是一個dealbreaker。
   9. 什麼是benchmark. ？怎麼判斷我的模型的表現，怎麼evaluation

12 -Meta analysis ⁃ Interview {survey;….} ⁃ Common algorithms s for detection (egg 16, faster rcnn u net mask r can generative adverbial networks ) 他都用了。

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-15-trackingcouting code

---

layout: post title: ‘trackingcouting code ‘ date: 2023-10-15T23:37:17-04:00

---

import ultralytics ultralytics.checks()

import supervision as sv import numpy as np from ultralytics import YOLO

print(“supervision.version:”, sv.version)

SOURCE_VIDEO_PATH = “vehicle-counting.mp4”

SOURCE_VIDEO_PATH = r”..\BrakeDetection\day_city.mp4”

SOURCE_VIDEO_PATH = r”..\BrakeDetection\Braking.mp4”

SOURCE_VIDEO_PATH = “..\BrakeDetection\lane_changing.MP4”

SOURCE_VIDEO_PATH = “..\BrakeDetection\new.m4v”

TARGET_VIDEO_PATH = “EMERG_complex.mp4”

TARGET_VIDEO_PATH = “couting_result1.mp4”

SOURCE_VIDEO_PATH = “2023_07_26_122542_N_A_reencoded.mp4”

MODEL = “yolov8x.pt”

MODEL = “best.pt”

model = YOLO(MODEL) model.fuse()

settings

LINE_START = sv.Point(50, 1500) LINE_END = sv.Point(3840-50, 1500)

dict maping class_id to class_name

CLASS_NAMES_DICT = model.model.names

class_ids of interest - person, byclcle, car, motorcycle, bus and truck, traffic light, stop sign

selected_classes = [0, 1, 2, 3, 5, 7, 9, 11]

generator = sv.get_video_frames_generator(SOURCE_VIDEO_PATH)

create BYTETracker instance

byte_tracker = sv.ByteTrack(track_thresh=0.25, track_buffer=30, match_thresh=0.8, frame_rate=30)

create VideoInfo instance

video_info = sv.VideoInfo.from_video_path(SOURCE_VIDEO_PATH) print(“!!!!!!!!!”) print(video_info.fps, video_info.total_frames, video_info.resolution_wh, video_info.width, video_info.height)

create LineZone instance, it is previously called LineCounter class

line_zone = sv.LineZone(start=LINE_START, end=LINE_END)

create instance of BoxAnnotator

box_annotator = sv.BoxAnnotator(thickness=4, text_thickness=4, text_scale=2)

create instance of TraceAnnotator

trace_annotator = sv.TraceAnnotator(thickness=4, trace_length=50)

create LineZoneAnnotator instance, it is previously called LineCounterAnnotator class

line_zone_annotator = sv.LineZoneAnnotator(thickness=4, text_thickness=4, text_scale=2)

define call back function to be used in video processing

def callback(frame: np.ndarray, index:int) -> np.ndarray: # model prediction on single frame and conversion to supervision Detections results = model(frame, verbose=False)[0] detections = sv.Detections.from_ultralytics(results) # only consider class id from selected_classes define above detections = detections[np.isin(detections.class_id, selected_classes)] # tracking detections detections = byte_tracker.update_with_detections(detections) labels = [ f”#{tracker_id} {model.model.names[class_id]} {confidence:0.2f}” for _, _, confidence, class_id, tracker_id in detections ] annotated_frame = trace_annotator.annotate( scene=frame.copy(), detections=detections ) annotated_frame=box_annotator.annotate( scene=annotated_frame, detections=detections, labels=labels)

# update line counter
line_zone.trigger(detections)
# return frame with box and line annotated result
return  line_zone_annotator.annotate(annotated_frame, line_counter=line_zone)

process the whole video

sv.process_video( source_path = SOURCE_VIDEO_PATH, target_path = TARGET_VIDEO_PATH, callback=callback )

#tracking #couting

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-15-是我兩個yolov8的模型，他們的class如上。 我能把這兩個模型融合成一個，然後讓那個模型能夠檢測所有…

2023-10-15-是我兩個yolov8的模型，他們的class如上。 我能把這兩個模型融合成一個，然後讓那個模型能夠檢測所有的class嗎

---

layout: post title: ‘是我兩個yolov8的模型，他們的class如上。 我能把這兩個模型融合成一個，然後讓那個模型能夠檢測所有的class嗎’ date: 2023-10-15T23:18:22-04:00

---

将两个已训练的YOLO模型合并为一个模型并不是一个简单的任务，尤其是如果它们的架构或训练数据有所不同。然而，有一些方法可以尝试融合两个模型的能力，以便它们可以在一个统一的模型中识别所有的类别。以下是一些可能的方法：

1. 重新训练单一模型： 最直接的方法是从头开始，使用包含所有感兴趣类别的新数据集来重新训练单个YOLO模型。这种方法的好处是它可以从头开始学习识别所有类别，而不需要处理合并不同模型的复杂性。

2. 模型融合： 一种更复杂的方法是尝试融合两个模型。这可能包括合并它们的架构和权重，但这是一个非常技术和复杂的任务，可能需要深度学习和模型融合方面的专业知识。

3. 多模型集成： 你可以同时运行两个模型，并将它们的结果合并到一个单独的输出中。例如，你可以首先运行第一个模型来识别车辆，然后运行第二个模型来确定它们的制动状态。然后，你可以将两个模型的结果合并到一个单独的输出中。虽然这种方法不会产生一个单独的模型，但它可以帮助你在一个系统中识别所有需要的类别。

from ultralytics import YOLO

# Load the models
model1 = YOLO('yolov8_1.cfg', 'yolov8_1.weights', 'yolov8_1.names')
model2 = YOLO('yolov8_2.cfg', 'yolov8_2.weights', 'yolov8_2.names')

# Perform inference with both models
results1 = model1('image.jpg')
results2 = model2('image.jpg')

# Combine the results (this is a simplistic approach and may require further processing)
combined_results = results1 + results2

# ...process the combined results...

这些是实现你想要功能的一些可能的方法。每种方法都有其优势和劣势，可能需要不同程度的技术知识和额外的数据或资源。最好的方法可能取决于你的具体需求和可用资源。

#模型融合

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-15-drone tracking and counting

---

layout: post title: ‘drone tracking and counting ‘ date: 2023-10-15T19:35:19-04:00

---

https://github.com/roboflow/supervision/tree/develop/examples/traffic_analysis

#drone #tracking #counting

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-15-安裝cython-bbox

---

layout: post title: ‘安裝cython-bbox ‘ date: 2023-10-15T18:16:00-04:00

---

Under Windows OS:pip install -e git+https://github.com/samson-wang/cython_bbox.git#egg=cython-bboxThe package support for windows is not yet available via PyPI, but it is possible if you install it using its github repo link

#cython #bbox

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-15-本地部署cythonbox tracker

---

layout: post title: ‘本地部署cythonbox tracker ‘ date: 2023-10-15T17:58:07-04:00

---

你提供的代码是用于在 Jupyter Notebook 中运行的，而且在云环境（例如 Google Colab）中运行。在这种环境中，你可以使用感叹号 (!) 来运行 shell 命令。但在你的本地机器上，你需要在你的命令行终端（例如 PowerShell 或命令提示符）中运行这些命令，而不是在 Jupyter Notebook 中运行。

请按照以下步骤操作：

1. 克隆 Git 仓库:

    cd path_to_your_desired_directory
    git clone https://github.com/ifzhang/ByteTrack.git
    cd ByteTrack
   

2. 修改 requirements.txt (如果需要的话):
   • 使用文本编辑器打开 requirements.txt 文件。
   • 找到 onnx==1.8.1 并将其改为 onnx==1.9.0。
   • 保存并关闭文件。
3. 安装依赖项:

    pip install -r requirements.txt
   

4. 运行 setup.py:

    python setup.py develop
   

5. 安装其他依赖项:

    pip install cython_bbox onemetric loguru lap thop
   

6. 验证安装:
   • 现在你可以打开 Python 解释器或创建一个新的 Python 脚本，然后运行以下代码以确保所有东西都按预期工作： ```python import sys sys.path.append(‘path_to_ByteTrack_directory’) # 替换为你的 ByteTrack 目录的路径

   import yolox print(“yolox.version:”, yolox.version) ```

请注意，如果你在执行这些命令时遇到任何问题，你可能需要以管理员权限运行你的命令行终端。

#cython #tracker

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-15-好了，教我怎麼給我的video做這個lstm的訓練吧。我只有視頻數據，記住。我也沒有任何的標籤

---

layout: post title: ‘好了，教我怎麼給我的video做這個lstm的訓練吧。我只有視頻數據，記住。我也沒有任何的標籤’ date: 2023-10-15T04:47:27-04:00

---

既然您只有视频数据且没有标签，我们将采用一个稍微不同的方法：我们首先从视频中提取特征，然后使用自动标注的策略来为训练数据创建标签，并使用LSTM进行训练。由于您没有真实的标签，这种方法的准确性可能会受到影响，但它仍然为您提供了一个开始。

步骤1：从视频中提取特征

1. 刹车灯频率
2. 跟车距离

import cv2
import numpy as np

def extract_features_from_frame(frame):
    # 这里只是一个示例。您需要使用物体检测算法来实际提取特征。
    brake_light_frequency = np.random.rand()  # 使用您的刹车灯检测算法替换
    following_distance = np.random.rand()     # 使用您的跟车距离算法替换
    return brake_light_frequency, following_distance

video_path = "your_video_path_here.mp4"
cap = cv2.VideoCapture(video_path)

brake_light_frequencies = []
following_distances = []

while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break
    brake_light_freq, follow_dist = extract_features_from_frame(frame)
    brake_light_frequencies.append(brake_light_freq)
    following_distances.append(follow_dist)

cap.release()

步骤2：自动标注数据

基于前面的策略来标注数据。

def generate_labels(brake_frequencies, following_distances, brake_threshold=0.5, distance_threshold=0.3):
    labels = []
    for i in range(len(brake_frequencies) - 5):  
        next_5_seconds_brake_freq = brake_frequencies[i:i+5]
        next_5_seconds_follow_dist = following_distances[i:i+5]
        
        if any(freq > brake_threshold for freq in next_5_seconds_brake_freq) and any(dist < distance_threshold for dist in next_5_seconds_follow_dist):
            labels.append(1)  # 危险
        else:
            labels.append(0)  # 安全
    return labels

labels = generate_labels(brake_light_frequencies, following_distances)

步骤3：使用LSTM进行训练

from keras.models import Sequential
from keras.layers import LSTM, Dense

def create_dataset(data, labels, window_size=30):
    X, y = [], []
    for i in range(len(data) - window_size):
        X.append(data[i:i+window_size])
        y.append(labels[i + window_size])
    return np.array(X), np.array(y)

features = list(zip(brake_light_frequencies, following_distances))
X, y = create_dataset(features, labels)

model = Sequential()
model.add(LSTM(50, input_shape=(X.shape[1], X.shape[2]))) 
model.add(Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
model.fit(X, y, epochs=10, batch_size=64, validation_split=0.2)

这就是整个流程。但请注意，上面的代码仅供参考，很多细节部分（例如从视频帧中真实地提取特征）您可能需要根据实际情况来定制。

#lstm #煞車預測危險 #訓練 #特徵提取

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-15-如果在未来5秒内，煞车灯的频率超过了某个阈值（表示连续煞车）并且跟车距离低于另一个阈值，那么标签为“危险…

2023-10-15-如果在未来5秒内，煞车灯的频率超过了某个阈值（表示连续煞车）并且跟车距离低于另一个阈值，那么标签为“危险”。 你提到是未來的5秒。是不是在訓練的時候，是要用未來的數據來標記歷史數據的。 喔在testde 的時候，根本就不知道未來數據怎麼辦呢

---

layout: post title: ‘如果在未来5秒内，煞车灯的频率超过了某个阈值（表示连续煞车）并且跟车距离低于另一个阈值，那么标签为“危险”。 你提到是未來的5秒。是不是在訓練的時候，是要用未來的數據來標記歷史數據的。 喔在testde 的時候，根本就不知道未來數據怎麼辦呢’ date: 2023-10-15T04:43:54-04:00

---

您完全正确。当我们训练模型时，我们使用过去的数据来预测未来的事件。为了这样做，我们确实需要知道未来的数据来正确地为过去的数据创建标签。但在真实的测试或部署中，当我们希望预测未来5秒内是否会有危险时，我们当然不会知道未来的数据。

这是时间序列预测中常见的策略，通常被称为”滞后标签”。我们在训练数据上使用滞后的方法来模拟真实世界的预测场景。但是，当我们部署模型并实际使用它时，我们仅使用当前和过去的数据作为输入，并期望模型能够准确预测未来。

为了明确：

• 训练阶段：使用历史数据和未来5秒的数据（滞后）来为每个时间点生成标签。然后，使用这些标签和历史数据来训练模型。
• 测试/部署阶段：只有当前和过去的数据可用。使用训练好的模型预测未来5秒内是否会有危险。

为了确保您的模型在真实世界中表现良好，建议使用时间序列交叉验证方法，其中训练集和验证集在时间上是连续的，确保验证集总是在训练集之后。这样可以模拟真实世界中的预测场景。

#滯後標籤 #煞車 #lstm #煞車頻率

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-15-3. 数据标注

您需要为每个时间点标注未来5秒的危险级别。这通常需要手动操作或其他可靠的数据源。 為什麼要這麼做。。 危險級別是我說危險就危險的嗎？ 難道不應該由煞車燈和煞車距離隨時間的變化來看的嗎 —

layout: post title: ‘3. 数据标注 您需要为每个时间点标注未来5秒的危险级别。这通常需要手动操作或其他可靠的数据源。 為什麼要這麼做。。 危險級別是我說危險就危險的嗎？ 難道不應該由煞車燈和煞車距離隨時間的變化來看的嗎’ date: 2023-10-15T04:41:40-04:00

---

抱歉，我理解您的困惑。您是对的，我们可以基于特定的观察来推断是否存在危险，而不仅仅是手动标记。例如，如果煞车灯频繁闪烁且跟车距离突然减小，那很可能会出现危险。

如果我们使用视频中的特征来推断危险，那么这些特征变得尤为重要。我们可以使用如下逻辑来创建标签：

• 如果在未来5秒内，煞车灯的频率超过了某个阈值（表示连续煞车）并且跟车距离低于另一个阈值，那么标签为“危险”。
• 否则，标签为“安全”。

以这种方式，您可以使用数据自动为每个时间点生成标签，而不需要手动操作。

以下是一个简化的示例，展示如何根据上述逻辑生成标签：

def generate_labels(brake_frequencies, following_distances, brake_threshold, distance_threshold):
    labels = []
    for i in range(len(brake_frequencies) - 5):  # 假设数据每秒有1帧
        next_5_seconds_brake_freq = brake_frequencies[i:i+5]
        next_5_seconds_follow_dist = following_distances[i:i+5]
        
        if any(freq > brake_threshold for freq in next_5_seconds_brake_freq) and any(dist < distance_threshold for dist in next_5_seconds_follow_dist):
            labels.append(1)  # 危险
        else:
            labels.append(0)  # 安全
    return labels

brake_frequencies = ...  # 您从视频中提取的刹车灯频率数据
following_distances = ...  # 您从视频中提取的跟车距离数据
brake_threshold = ...  # 您选择的刹车灯频率阈值
distance_threshold = ...  # 您选择的跟车距离阈值

labels = generate_labels(brake_frequencies, following_distances, brake_threshold, distance_threshold)

这种方法的好处是它可以自动地为您的数据集生成标签，不需要额外的手动努力。但值得注意的是，为了确保这种方法的效果，您可能需要仔细选择和调整阈值。

#煞車數據 #判斷 #危險 #跟車距離

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-15-滑动窗口技术：基于连续的帧，使用滑动窗口提取时间序列特征。 這一個技術具體點，比如說我要提取10秒這個時…

2023-10-15-滑动窗口技术：基于连续的帧，使用滑动窗口提取时间序列特征。 這一個技術具體點，比如說我要提取10秒這個時間段內，煞車的頻率或者跟車距離的變化。我怎麼搞，

---

layout: post title: ‘滑动窗口技术：基于连续的帧，使用滑动窗口提取时间序列特征。 這一個技術具體點，比如說我要提取10秒這個時間段內，煞車的頻率或者跟車距離的變化。我怎麼搞，’ date: 2023-10-15T04:29:07-04:00

---

滑动窗口技术是一种常用的时间序列数据处理方法，通过它，你可以在连续的数据点（在你的案例中是视频帧）上应用计算和统计分析。以下是如何具体实现基于滑动窗口的特征提取：

---

1. 确定窗口大小和步长：

• 窗口大小：这是您想要考虑的连续帧的数量。例如，如果您的视频是30帧/秒，要提取10秒的数据，窗口大小应为300帧。
• 步长：决定每次滑动窗口移动多少帧。例如，步长为30意味着每次滑动1秒。

2. 初始化：

• 开始从视频的第一帧，并获取第一个窗口的数据。

3. 特征计算：

• 煞车频率：在当前窗口内，计算刹车灯亮起的次数。这可以通过检测亮起和熄灭之间的转换来完成。
• 跟车距离变化：记录窗口内的每一帧的跟车距离，然后计算其平均值、最大值、最小值、标准差等统计量。

4. 滑动窗口：

• 将窗口按照预定的步长向前移动，然后返回步骤3进行下一个窗口的特征计算。

5. 结束条件：

• 当窗口到达视频的末尾或剩余帧数少于窗口大小时，结束处理。

6. 输出和存储：

• 对于每一个窗口，你将有一组特征（例如，10秒内的平均跟车距离、煞车频率等）。将这些特征存储为后续分析和模型训练的输入。

---

对于编程实现，你可以使用Python及其相关库（如NumPy和OpenCV）进行这一过程。在处理过程中，数组和循环结构将是您的主要工具。确保在处理过程中监视输出，检查结果的合理性，这有助于识别并纠正任何可能出现的错误。

#滑動窗口 #時間序列 #特徵工程

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-15-特征工程：

基于物体检测的结果，从每个视频帧中提取特征。这可能包括物体的数量、位置、类型等。 根据连续的帧创建更复杂的特征，如跟车距离的变化率、刹车灯的频率等。這個很難做。數據不都是一幀一幀的嘛。每幀數據怎麼能夠反映出前後的變化或者煞車燈的頻率呢。 —

layout: post title: ‘特征工程： 基于物体检测的结果，从每个视频帧中提取特征。这可能包括物体的数量、位置、类型等。 根据连续的帧创建更复杂的特征，如跟车距离的变化率、刹车灯的频率等。這個很難做。數據不都是一幀一幀的嘛。每幀數據怎麼能夠反映出前後的變化或者煞車燈的頻率呢。’ date: 2023-10-15T04:19:52-04:00

---

您是对的，单个帧本身无法捕捉到连续的变化。但是，通过组合多帧数据，我们可以创建表示时间序列变化的特征。以下是如何操作的一些建议：

1. 滑动窗口技术：
   • 使用固定数量的连续帧（例如，考虑每次5帧或10帧）作为一个“窗口”。
   • 对于这些帧中的每个特征（例如跟车距离），计算其在这个窗口中的变化（例如平均值、最大值、最小值、标准差等）。
   • 这样，每个窗口都可以产生一个特征向量，表示在该时间段内的变化。
2. 跟车距离的变化率：
   • 使用连续的帧来计算跟车距离的变化。例如，( \Delta d = d_{t} - d_{t-1} ) 其中 ( d ) 是跟车距离，( t ) 是当前帧。
   • 这个变化率可以表示驾驶员的跟车习惯，例如，如果经常为负值，则可能经常接近前车。
3. 刹车灯频率：
   • 对于每个滑动窗口，计算刹车灯亮起的次数。
   • 如果您的视频是30fps，并且在5秒的窗口内刹车灯闪烁了15次，那么频率是3Hz。
4. 其他时间序列特征：
   • 对于其他感兴趣的物体或事件（如交通标志、转向指示灯等），同样可以使用滑动窗口计算它们的出现次数、持续时间等。
5. 时间戳同步：
   • 如果可能的话，确保每帧的时间戳与您的其他数据源（如GPS、速度等）同步。这将允许您轻松地将视频特征与其他数据源进行匹配和融合。

当您使用这些方法时，您的数据将从单帧特征转变为描述一段时间内的特征。这将为模型提供更多的上下文信息，帮助其更好地理解驾驶行为的模式和变化。

#特徵工程 #滑動窗口技術 #時間序列特徵

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-15-驾驶行为模式：

分析驾驶员在不同的道路条件、交通流量或时间段下的跟车距离和刹车行为。 这可以帮助识别驾驶员的驾驶模式，例如是否在高峰时段更容易驾驶得过于紧张。 這兩個可行。主要跟我分析下 —

layout: post title: ‘驾驶行为模式： 分析驾驶员在不同的道路条件、交通流量或时间段下的跟车距离和刹车行为。 这可以帮助识别驾驶员的驾驶模式，例如是否在高峰时段更容易驾驶得过于紧张。 這兩個可行。主要跟我分析下’ date: 2023-10-15T04:10:37-04:00

---

好的，我们重点分析这两个方面：

1. 驾驶员在不同的道路条件、交通流量或时间段下的跟车距离和刹车行为：

   • 道路条件：首先，我们需要从视频数据中识别道路条件。这包括道路类型（高速公路、城市街道、乡村道路等）、道路状况（干燥、潮湿、积雪、有沙石等）以及天气情况（晴天、雨天、雾天等）。

     分析在不同道路条件下，驾驶员的跟车距离是否会有显著变化。例如，驾驶员在雨天可能会保持更大的跟车距离，以应对突然的路面滑动。

     同样地，对于刹车行为，看看驾驶员在这些不同道路条件下是否更容易使用急刹车。

   • 交通流量：观察视频中的其他车辆数量，我们可以大致估计当前的交通流量，从而分为高、中、低流量。

     在高流量情况下，驾驶员可能更容易采用较短的跟车距离，因为车流比较密集。但这也可能增加急刹车的风险。

   • 时间段：如果您能知道视频的录制时间（例如从视频的元数据或其他来源），您可以将一天分成几个时间段：早高峰、上午、午间、下午、晚高峰、晚上。

     一些驾驶员在高峰时段可能会更加紧张或不耐烦，从而改变他们的驾驶习惯。观察在这些时间段内，驾驶员的跟车距离和刹车习惯是否有明显的变化。

2. 识别驾驶模式：

   • 结合上述分析，我们可以定义几种驾驶模式。例如：“紧张型”（在高峰或高流量时跟车距离短、频繁刹车）、“稳定型”（无论何时跟车距离都相对稳定，刹车平稳）等。

   • 使用聚类或分类算法，根据驾驶员在各种情境下的行为，将其驾驶模式进行归类。

   • 这样的模式识别可以帮助驾驶员意识到自己的驾驶习惯，并在需要的时候进行调整，以提高安全性。

此类分析的最终目标是提高道路安全并为驾驶员提供有关他们驾驶习惯的反馈。这可以通过一个交互式的仪表盘或应用来完成，其中显示了他们的驾驶模式和建议的改进方法。

#driving #behaviour #distance

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-15-驾驶行为模式：

分析驾驶员在不同的道路条件、交通流量或时间段下的跟车距离和刹车行为。 这可以帮助识别驾驶员的驾驶模式，例如是否在高峰时段更容易驾驶得过于紧张。 這兩個可行。主要跟我分析下 —

layout: post title: ‘驾驶行为模式： 分析驾驶员在不同的道路条件、交通流量或时间段下的跟车距离和刹车行为。 这可以帮助识别驾驶员的驾驶模式，例如是否在高峰时段更容易驾驶得过于紧张。 這兩個可行。主要跟我分析下’ date: 2023-10-15T04:10:26-04:00

---

好的，我们重点分析这两个方面：

1. 驾驶员在不同的道路条件、交通流量或时间段下的跟车距离和刹车行为：

   • 道路条件：首先，我们需要从视频数据中识别道路条件。这包括道路类型（高速公路、城市街道、乡村道路等）、道路状况（干燥、潮湿、积雪、有沙石等）以及天气情况（晴天、雨天、雾天等）。

     分析在不同道路条件下，驾驶员的跟车距离是否会有显著变化。例如，驾驶员在雨天可能会保持更大的跟车距离，以应对突然的路面滑动。

     同样地，对于刹车行为，看看驾驶员在这些不同道路条件下是否更容易使用急刹车。

   • 交通流量：观察视频中的其他车辆数量，我们可以大致估计当前的交通流量，从而分为高、中、低流量。

     在高流量情况下，驾驶员可能更容易采用较短的跟车距离，因为车流比较密集。但这也可能增加急刹车的风险。

   • 时间段：如果您能知道视频的录制时间（例如从视频的元数据或其他来源），您可以将一天分成几个时间段：早高峰、上午、午间、下午、晚高峰、晚上。

     一些驾驶员在高峰时段可能会更加紧张或不耐烦，从而改变他们的驾驶习惯。观察在这些时间段内，驾驶员的跟车距离和刹车习惯是否有明显的变化。

2. 识别驾驶模式：

   • 结合上述分析，我们可以定义几种驾驶模式。例如：“紧张型”（在高峰或高流量时跟车距离短、频繁刹车）、“稳定型”（无论何时跟车距离都相对稳定，刹车平稳）等。

   • 使用聚类或分类算法，根据驾驶员在各种情境下的行为，将其驾驶模式进行归类。

   • 这样的模式识别可以帮助驾驶员意识到自己的驾驶习惯，并在需要的时候进行调整，以提高安全性。

此类分析的最终目标是提高道路安全并为驾驶员提供有关他们驾驶习惯的反馈。这可以通过一个交互式的仪表盘或应用来完成，其中显示了他们的驾驶模式和建议的改进方法。

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-15-brake distance light

---

layout: post title: ‘brake distance light ‘ date: 2023-10-15T04:07:27-04:00

---

当然可以。跟车距离和刹车灯亮起是交通安全研究中的重要因素。结合这两个信息，可以帮助您分析驾驶员的驾驶习惯、安全意识以及可能的危险情况。以下是如何利用这两个因素进行研究：

1. 刹车反应时间：
   • 从刹车灯亮起的时间和驾驶员实际开始减速的时间之间的差异，可以估计驾驶员的反应时间。
   • 这可以帮助评估驾驶员是否及时注意到前方的变化。
2. 安全跟车距离：
   • 结合速度，您可以计算驾驶员在不同速度下通常保持的安全跟车距离。
   • 如果跟车距离经常小于推荐的安全距离（通常基于车速），这可能表明驾驶员有尾随过近的习惯。
3. 危险预测：
   • 如果驾驶员在跟车距离过短时经常刹车，这可能意味着他们经常遭遇接近碰撞的情况。
   • 结合其他数据，如车速，您可以预测在哪些情况下驾驶员最有可能面临危险。
4. 驾驶行为模式：
   • 分析驾驶员在不同的道路条件、交通流量或时间段下的跟车距离和刹车行为。
   • 这可以帮助识别驾驶员的驾驶模式，例如是否在高峰时段更容易驾驶得过于紧张。
5. 教育和培训：
   • 根据上述分析，提供反馈给驾驶员，帮助他们了解自己的驾驶习惯。
   • 建议他们如何保持安全跟车距离，并在需要时正确刹车。
6. 技术应用：
   • 如果您的系统具备实时处理能力，您可以开发一个驾驶辅助系统，当检测到驾驶员跟车过近且可能需要刹车时，发出预警。
7. 长期监控与评估：
   • 通过长期监测一个驾驶员的跟车距离和刹车行为，可以评估他们的驾驶习惯是否有所改进或恶化。

为了准确进行上述分析，您需要确保视频数据的清晰度足够识别前方车辆的刹车灯和估计跟车距离。此外，结合其他数据，如速度和加速度，可以提供更全面的分析。

#brake

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-15-車輛煞車燈亮起這個數據 可以怎麼分析

---

layout: post title: ‘車輛煞車燈亮起這個數據 可以怎麼分析’ date: 2023-10-15T03:05:33-04:00

---

驾驶员行为分析： • 急刹车频率：统计特定时间段或距离内的急刹车次数。频繁的急刹车可能意味着驾驶员分心、驾驶过于冒险或路况不佳。 • 刹车习惯：结合速度和加速度数据，分析驾驶员是渐进式刹车还是急刹车，从而提供驾驶培训和建议。交通流量和路况分析： • 交通堵塞检测：频繁的刹车可能是交通堵塞的迹象。 • 危险路段/交叉口识别：某些路段或交叉口可能存在更频繁的刹车行为，这些区域可能需要进一步的交通安全措施。

#brake #breake #drivingbehaviour

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-14-ustoopia/Live-stream-server-portable-Windows-Nginx-RTMP…

2023-10-14-ustoopia/Live-stream-server-portable-Windows-Nginx-RTMP-HLS-Dash 這個設置步驟給我

---

layout: post title: ‘ustoopia/Live-stream-server-portable-Windows-Nginx-RTMP-HLS-Dash 這個設置步驟給我’ date: 2023-10-14T17:22:25-04:00

---

要在Windows上设置和运行ustoopia/Live-stream-server-portable-Windows-Nginx-RTMP-HLS-Dash，请按照以下步骤操作：

1. 检查端口80:
   • 在开始之前，请检查您的PC上是否有正在使用端口80的程序（例如web服务器）。如果有，请禁用它，否则Nginx将与该程序冲突，因为只有一个进程可以使用一个端口【43†(source)】。
2. 下载和解压:
   • 从GitHub下载最新的发布版本：github.com/ustoopia/Live-stream-server-portable-Windows-Nginx-RTMP-HLS-Dash/releases。解压zip文件的内容到您喜欢的任何位置。在示例视频中，选择C:\livestream作为解压位置【43†(source)】。
3. 使用Windows Powershell:
   • 以管理员身份运行Windows Powershell。如果您选择了不同的位置，请编辑下面的命令：

     dir C:\livestream -Recurse | Unblock-File
     

   • 如果您看到上述消息，那么一切正常，您可以通过双击“NGINX.exe”继续。当您这样做时，可能看不到任何事情发生，但当您检查任务管理器时，您会看到Nginx现在有两个正在运行的进程。打开您的web浏览器，转到localhost/以确认您会在那里看到一个默认的Nginx页面。要测试流媒体是否也在工作，启动您的直播流客户端，并编辑您想要流式传输到的服务器的设置。确保它显示为：s with live-stream key: stream。现在开始流媒体！【43†(source)】。
4. 检查流和配置:
   • 查看localhost/stat上的统计信息页面，以查看所有流是否正常。这结束了本指南的基本第一步。如果您对此感到满意，请继续！但在做出这个决定之前，我想通知您以下内容：
     • 通过将流的许多视频片段写入硬盘驱动器来创建HLS和Dash流。不久之后，它们会再次被删除。如果这种情况经常发生（例如您24/7流式传输），则可能需要将它用于写入这些文件的文件夹移动到外部USB驱动器上。因为许多读/写操作会缩短您的驱动器的使用寿命，尤其是如果它是SSD驱动器。因此，最好的做法是使用除C驱动器之外的任何驱动器。您的最佳选择是使用> 2GB的USB驱动器或存储卡【43†(source)】。

这些步骤应该帮助您在Windows上设置和运行ustoopia/Live-stream-server-portable-Windows-Nginx-RTMP-HLS-Dash。在设置过程中遇到任何问题，请参考原始的GitHub Wiki指南或在相关的社区和论坛中寻求帮助。

#stream #rtmp #windows #nginx

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-10-body 和struct 是不是都屬於view的一個subclass？

---

layout: post title: ‘body 和struct 是不是都屬於view的一個subclass？’ date: 2023-10-10T22:19:00-04:00

---

不完全是。在SwiftUI中，View 是一个协议(protocol)，不是一个类(class)，所以我们不会说 struct 或 body 是 View 的子类(subclass)，而是说它们遵循(或实现)了 View 协议。

以下是详细的解释：

1. struct 和 View 协议:
   • 在SwiftUI中，你会通过创建实现 View 协议的 struct 来定义视图。这意味着你的 struct 必须提供 View 协议所需的所有属性和方法。其中最重要的一个是 body 属性。

      struct ContentView: View {  // ContentView 是一个遵循 View 协议的结构体
       var body: some View {
           Text("Hello, World!")
       }
      }
     

2. body 属性:
   • body 是 View 协议的一个要求。它是一个计算属性，返回一个遵循 View 协议的对象，通常是一个由其他视图组成的视图体系结构。body 属性描述了视图的内容和布局。

      var body: some View {
       Text("Hello, World!")
      }
     

在这个系统中，struct 和 body 不是 View 的子类，而是 View 协议的实现者。struct 是定义视图的主要方式，而 body 属性是你定义视图内容和布局的地方。通过遵循 View 协议，并提供必要的 body 属性，你的 struct 成为了一个完全功能的SwiftUI视图。

#struct #body #view #swift

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-10-@State private var isButtonEnabled = true 是不是意味著 有了…

2023-10-10-@State private var isButtonEnabled = true 是不是意味著 有了@state就說明variable一直是變動的

---

layout: post title: ‘@State private var isButtonEnabled = true 是不是意味著 有了@state就說明variable一直是變動的’ date: 2023-10-10T21:55:43-04:00

---

不完全是。@State 是一个属性包装器，它提供了一种机制来监视变量的变化，并在变量的值发生变化时重新渲染视图。然而，只有当变量的值实际发生变化时，视图才会重新渲染。换句话说，@State 并不意味着变量会不断变化，而是当它确实发生变化时，视图会得到更新。

这里的关键点是 @State 提供了一种监视和响应变量值变化的机制。它是 SwiftUI 中状态管理的基础，使得你可以创建响应式 UI，这些 UI 能够根据用户交互和其他事件自动更新。

在给定的示例中：

@State private var isButtonEnabled = true

isButtonEnabled 是一个状态变量，它的初始值是 true。当 isButtonEnabled 的值改变时（例如，通过用户交互），视图会得到通知，并重新渲染以反映新的状态。如果 isButtonEnabled 的值没有变化，视图不会重新渲染。

@State 是为单个视图的本地状态设计的。当你想要在视图之间共享状态时，你可能会使用其他工具和模式，例如 @ObservedObject、@EnvironmentObject 或 @Published。

#swift #deco #state

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-10-swift

---

layout: post title: ‘swift ‘ date: 2023-10-10T21:54:43-04:00

---

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-10-virtualenv pi

---

layout: post title: ‘virtualenv pi ‘ date: 2023-10-10T20:52:42-04:00

---

从你的输出中看来，virtualenv 被安装在 Python 2.7 的环境下，但virtualenv命令似乎没有正确配置在你的系统路径中，所以系统找不到 virtualenv 命令。我们可以尝试使用 python 或 python3 命令明确调用 virtualenv。下面是操作步骤：

1. 使用 Python 3 安装 virtualenv: 如果你的系统上已经安装了 Python 3，你可以尝试使用以下命令重新安装 virtualenv：

   python3 -m pip install --user virtualenv
   

2. 创建虚拟环境: 现在，使用 Python 3 创建一个新的虚拟环境：

   python3 -m virtualenv cv_env
   

3. 激活虚拟环境: 用以下命令激活你的虚拟环境：

   source cv_env/bin/activate
   

现在你应该能看到终端提示符前有 cv_env，表示虚拟环境已经激活。在这个虚拟环境中，你可以安装 OpenCV 和运行你的摄像头测试脚本。

如果上述步骤不起作用或者你的系统上没有 Python 3，请告诉我，我会提供进一步的帮助。

#PI #virtualenv

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-10-public class HuskIdleState : HuskGroundState 這句話是不是可以…

2023-10-10-public class HuskIdleState : HuskGroundState 這句話是不是可以說明，如果idle state出現，那他一定是ground state

---

layout: post title: ‘public class HuskIdleState : HuskGroundState 這句話是不是可以說明，如果idle state出現，那他一定是ground state ‘ date: 2023-10-10T18:05:54-04:00

---

是的，你完全正确。在这个语句public class HuskIdleState : HuskGroundState中，HuskIdleState是继承自HuskGroundState的。这意味着HuskIdleState是一个HuskGroundState的实例，它继承了HuskGroundState的所有公共和受保护的属性和方法。

在面向对象编程中，这种关系通常被称为”是一个（is-a）”关系。在这个例子中，HuskIdleState是一个HuskGroundState，因为它继承了HuskGroundState的所有功能，并可能还添加了一些自己的功能。这是通过继承机制实现的，继承允许一个类（子类）继承另一个类（父类）的属性和方法，并允许子类添加或覆盖父类的行为。

因此，如果Husk对象当前处于HuskIdleState，那么它也处于HuskGroundState，因为HuskIdleState是HuskGroundState的一个特定形式。这种继承关系允许你组织和结构化你的代码，以反映游戏对象和状态之间的逻辑关系。

#Unity #statemachine

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-10-值得學習的github

---

layout: post title: ‘值得學習的github ‘ date: 2023-10-10T05:57:06-04:00

---

Geesung Oh

#github #brakedetection

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-08-為什麼我的enemy進入不了idle state

---

layout: post title: ‘為什麼我的enemy進入不了idle state’ date: 2023-10-08T18:36:13-04:00

---

在你提供的代码中，Enemy_Husk类和HuskIdleState类似乎被逻辑定义了，但是为了确保enemyStateMachine被正确初始化，并且huskIdleState被正确设置为初始状态，你需要确认以下几点：

1. 确保enemyStateMachine已被实例化： 在Enemy_Husk类的Awake或Start方法中，你应该确保enemyStateMachine已被实例化。如果enemyStateMachine是null，那么调用enemyStateMachine.Initialize(huskIdleState)将会失败。

protected override void Awake()
{
    base.Awake();
    enemyStateMachine = new EnemyStateMachine();
    huskIdleState = new HuskIdleState(this, enemyStateMachine, "Idle", this);
    huskMoveState = new HuskMoveState(this, enemyStateMachine, "Move", this);
}

1. 检查EnemyStateMachine类的Initialize方法： 确保EnemyStateMachine类的Initialize方法正确地设置currentState为传递的状态，并确保Enter方法被调用。

public class EnemyStateMachine
{
    public EnemyState currentState;

    public void Initialize(EnemyState _startState)
    {
        currentState = _startState;
        currentState.Enter();
    }

    // ... other code ...
}

1. 添加调试日志： 为了诊断问题，可以在EnemyStateMachine类的Initialize方法和EnemyState类的Enter方法中添加调试日志。

public void Initialize(EnemyState _startState)
{
    Debug.Log("Initializing state: " + _startState.GetType().Name);
    currentState = _startState;
    currentState.Enter();
}

public virtual void Enter()
{
    Debug.Log("Entering state: " + GetType().Name);
    // ... other code ...
}

1. 检查Unity控制台的错误和警告： 确保Unity控制台中没有任何错误或警告，这些错误或警告可能会阻止状态机正常工作。

通过这些步骤，你应该能够诊断并解决enemyStateMachine无法进入huskIdleState的问题。

#Unity #idlestate #statemchine

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-07-你讲讲 unity 的animator里面，有个trigger的类型。 什么时候该用trigger，什么…

2023-10-07-你讲讲 unity 的animator里面，有个trigger的类型。 什么时候该用trigger，什么时候该用bool？ 以我现在的游戏概念为例子来讲解

---

layout: post title: ‘你讲讲 unity 的animator里面，有个trigger的类型。 什么时候该用trigger，什么时候该用bool？ 以我现在的游戏概念为例子来讲解’ date: 2023-10-07T01:18:59-04:00

---

在Unity的Animator中，Trigger和Bool都是Parameter类型，用于控制动画状态机的转换。它们的主要差异是如何重置和行为表现。

Trigger：

• 当一个触发器（Trigger）被设置后，它会立刻触发与其关联的状态转换。
• 一旦触发，它会自动重置，不需要手动重置。
• 主要用于一次性的动作，例如跳跃、攻击等。

Bool：

• Bool是一个简单的真/假值。
• 你需要手动设置它的值，即设置为真或假。
• 通常用于持续性的动作或状态，例如走路、跑步或是否正在地面上。

以你的游戏为例：

1. 敌人的状态机：

• 如果你的敌人在碰到墙壁时需要做一个掉头的动画，然后再继续行走，那么你可以使用Trigger。因为这是一个一次性的动作，当敌人碰到墙壁时，你只需触发这个动画，然后继续行走的动画。

• 如果你的敌人有两种行走速度，例如走和跑，你可以使用Bool来控制。例如，当敌人在追逐玩家时，你可以设置一个叫做IsRunning的Bool值为真，敌人就会开始跑步动画。当玩家逃脱时，你再把这个值设置为假，敌人就会返回到行走动画。

1. 可以在地上爬和在天上飞的敌人：

• 当这个敌人决定飞起或降落时，你可以使用Trigger来触发一个起飞或降落的动画，因为这是一次性的动作。

• 对于敌人是在空中飞行还是在地面上行走的状态，你可以使用Bool。例如，你可以有一个叫做IsFlying的Bool值。当这个值为真时，敌人播放飞行动画，当这个值为假时，敌人播放行走动画。

总的来说，你可以根据你的需求选择使用Trigger还是Bool。如果你需要控制的是一次性的动作或事件，Trigger是一个很好的选择。如果你需要控制的是持续性的状态或行为，那么Bool可能更适合。

#Unity #Game #trigger #bool #uniyu

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-06-那我的敵人的的代碼。在folder裡面應該怎麼組織呢？ 是抖創建一個folder是你說的總的enemy的…

2023-10-06-那我的敵人的的代碼。在folder裡面應該怎麼組織呢？ 是抖創建一個folder是你說的總的enemy的代碼，然後分別在創建folder是飛的和地面上的？

---

layout: post title: ‘那我的敵人的的代碼。在folder裡面應該怎麼組織呢？ 是抖創建一個folder是你說的總的enemy的代碼，然後分別在創建folder是飛的和地面上的？’ date: 2023-10-06T15:45:29-04:00

---

組織你的代碼文件和文件夾是很重要的，特別是當你的項目增長和包含更多的檔案時。好的組織結構可以幫助你和你的團隊更容易地找到和維護代碼。

基於你的需求，以下是一些建議的文件夾結構：

Assets
│
└───Scripts
    │
    ├───Enemies
    │   │   Enemy.cs  (基本的敵人類)
    │   │   EnemyStateMachine.cs (狀態機類)
    │   │
    │   ├───EnemyStates
    │   │   │   EnemyState.cs (接口定義)
    │   │   │   IdleState.cs
    │   │   │   MovingState.cs
    │   │   │   AttackState.cs
    │   │   │   DeadState.cs
    │   │
    │   ├───GroundEnemies
    │   │   │   GroundEnemy.cs  (地面敵人的基類)
    │   │   │
    │   │   ├───Husk
    │   │       │   Husk.cs
    │   │
    │   ├───FlyingEnemies
    │   │   │   FlyingEnemy.cs  (飛行敵人的基類)
    │   │   │
    │   │   ├───Bat
    │           │   Bat.cs
    │
    ... (其他遊戲相關的文件夾和腳本)

這種結構提供了一些好處：

1. 模組化：每個文件夾都專注於一個特定的遊戲部分，如敵人、玩家或物品。
2. 易於導航：當你需要修改某個敵人的行為時，你知道去哪裡找到相關的腳本。
3. 擴展性：當你想添加新的敵人或遊戲功能時，你可以輕鬆地在相應的文件夾中添加新的腳本。

最後，儘管我提供了上述結構作為參考，但你應該根據你的遊戲的需求和你的偏好進行調整。選擇一個對你來說自然而且有意義的組織結構。

#Unity #Organization #structure #enemy

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-06-我這個代碼，怎麼當我退出這個狀態的時候，player的位置沒有在原來我存儲的位置啊

---

layout: post title: ‘我這個代碼，怎麼當我退出這個狀態的時候，player的位置沒有在原來我存儲的位置啊’ date: 2023-10-06T00:46:56-04:00

---

問題出在SitOnBench()這個方法上。在你的Update()中，你調用了SitOnBench()，這意味著每一幀你都在設置playerPastPosition為當前的玩家位置，然後再修改玩家的位置到椅子上。所以playerPastPosition每次都會被重置為椅子上的位置。

你應該在Enter()方法中只存儲一次玩家的初始位置，這樣當你退出這個狀態時，你可以將玩家的位置設回這個初始位置。這是修改後的代碼：

public class PlayerSitState : PlayerGroundState
{
    private Vector3 playerPastPosition;

    public PlayerSitState(Player player, PlayerStateMachine stateMachine, string _animBoolName) : base(player, stateMachine, _animBoolName)
    {
    }

    public override void Enter()
    {
        base.Enter();
        
        playerPastPosition = player.transform.position; // 存儲玩家當前的位置
        SitOnBench(); // 讓玩家坐下
    }

    public override void Exit()
    {
        player.transform.position = playerPastPosition; // 將玩家位置設置回初始位置

        base.Exit();
    }

    public override void Update()
    {
        base.Update();
        
        if (Input.GetButtonDown("Back"))
        {
            stateMachine.changeState(player.playerIdleState);
        }
    }

    private void SitOnBench()
    {
        player.transform.position = player.currentChair.position + new Vector3(0, 0.4f, 0);
    }
}

我把playerPastPosition的設置移到了Enter()中，這樣它只設置一次。然後我將玩家位置的修改移到了SitOnBench()，這樣它也只執行一次。

#Unity #bench #update #enter

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-04-hollo knight wiki

---

layout: post title: ‘hollo knight wiki’ date: 2023-10-04T22:17:52-04:00

---

https://hollowknight.fandom.com/wiki/Damage_Values_and_Enemy_Health_(Hollow_Knight)

這個是遊戲的一些npg 文件

https://drive.google.com/drive/folders/1lx02_w9TFTYdR3aggI1gbXcLr69roaNV?usp=sharing

#Unity #Game #hollowknight

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-02-自动驾驶rpg游戏

---

layout: post title: ‘自动驾驶rpg游戏’ date: 2023-10-02T04:02:46-04:00

---

构建RPG游戏中的具体场景和故事需要深入思考和详细规划。以下是一个更为详细的框架，以前面提到的AI Chronicles: The Autonomous Age为例：

---

1. 世界建构：

城市蓝图：设定一个大都市，名为NeuroCity。该城市被分为几个主要区域：

• Core District：城市的中心，是AI管理中心和权力中心。
• Outskirts：城市的边缘，一些反叛者和那些被系统排斥的人居住在这里。
• Commercial Hub：购物和娱乐中心。
• Industrial Zone：工厂和仓库，一些关于AI技术的秘密可能隐藏在这里。
• Green Belt：一个自然公园和休息区，但也有一些隐藏的秘密。

2. 主线任务：

起点：玩家醒来在Outskirts，失去了所有记忆，只知道自己曾经是一个AI开发者。游戏的目标是恢复记忆，揭露AI的秘密，并决定NeuroCity的未来。

任务一：玩家遇到一个反叛者，他提供了一个线索，可能与玩家的记忆有关。但要获得这个线索，玩家必须帮助反叛者完成一项任务。

任务二：线索指向Commercial Hub的一个老朋友。但这个朋友现在是一个成功的商人，他要求玩家为他做一些交换才会提供信息。

任务三：玩家必须进入Industrial Zone潜入一个秘密实验室，寻找与AI技术有关的证据。这需要玩家与AI助手合作，解决一系列的谜题。

结局：玩家最终发现，整个NeuroCity都是一个大型的实验，目的是研究人类和AI的共同生活。玩家面临一个决定：揭露这个秘密、加入AI或尝试创建一个人类和AI和谐共存的新世界。

3. 支线任务：

• 车辆升级：在Outskirts，玩家可以帮助一个老机械师寻找零件，以升级自己的车辆。
• AI助手的过去：玩家可以寻找线索，了解AI助手的过去和真正的目的。
• 反叛者的请求：玩家可以完成一系列任务，帮助Outskirts的反叛者，从而获得额外的资源和支持。

---

这只是一个基本的框架，实际的游戏开发会涉及到更多的细节和复杂性。但希望这能帮助你开始构思你的RPG游戏。

#Unity #games #idea

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-10-01-currentDashes–; 為什麼要用減法 而不是檢查加法？

---

layout: post title: ‘currentDashes–; 為什麼要用減法 而不是檢查加法？’ date: 2023-10-01T15:28:57-04:00

---

使用currentDashes--（减法）和currentDashes++（加法）都取决于你的游戏逻辑和你想达到的效果。在这个场景中，考虑currentDashes表示玩家当前可用的dash数量。

当玩家使用一个dash，你想减少他们可用的dash数量，因此你会使用currentDashes--。

为什么要这么做？考虑以下情景：

1. 假设玩家在开始时有2次dash机会。currentDashes = 2
2. 玩家按下dash按钮，执行dash动作。
3. currentDashes--会将currentDashes减少到1。
4. 如果玩家再次按下dash按钮，他们可以再dash一次。
5. 再次执行currentDashes--会将currentDashes减少到0，这意味着玩家不能再dash了，除非有某种机制重新为他们增加dash机会。

如果你使用加法，那么每次玩家dash，他们的dash次数会增加，这意味着他们有无限次的dash机会，这可能不是你想要的。

但是，如果你的游戏逻辑是每次玩家完成某个任务或收集某个物品时增加dash机会，那么你会使用currentDashes++。

总之，选择使用加法还是减法取决于你的游戏设计和你想达到的效果。

#Unity #dash #++ #cSharp

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-09-30-為什麼dash state 要繼承player state 而不是airs state or jump-state…

2023-09-30-為什麼dash state 要繼承player state 而不是airs state or jump-state

---

layout: post title: ‘為什麼dash state 要繼承player state 而不是airs state or jump-state ‘ date: 2023-09-30T14:59:29-04:00

---

在设计状态机和状态继承结构时，选择哪个状态来继承主要取决于你的游戏逻辑和机制。不过，通常有一些逻辑上的原因：

1. 功能的通用性：
   • PlayerState可能是所有其他状态的最基本的父状态。这意味着PlayerState中定义的功能适用于所有的状态。如果DashState需要这些通用的功能，那么从PlayerState继承是有意义的。
2. 特性的封装性：
   • 可能在AirState或JumpState中定义了一些只与空中动作或跳跃相关的特性。如果DashState并不需要这些特性，那么从这些状态继承可能会带来一些不需要的复杂性或功能。
3. 状态间的转换：
   • 如果DashState可以从任何状态（例如站立、行走、跳跃等）触发，那么将其与PlayerState更为接近的基本状态相关联可能更为合适。而如果dash只能在空中执行，那么从AirState继承可能更有意义。
4. 简化逻辑：
   • 通过从PlayerState直接继承，可以保持状态机的结构简洁和直观，避免创建过于复杂的状态继承链。
5. 状态独立性：
   • 如果dash在逻辑上与跳跃或空中状态没有太大的关系，那么将其作为一个从PlayerState继承的独立状态可能更合理。这样，DashState只包含与dash直接相关的逻辑，而不是继承其他状态的可能不相关的逻辑。

最后，这种设计选择也取决于具体的游戏和你的设计决策。可能在某些情境下，让DashState继承自AirState或JumpState更合适。主要是根据你的游戏机制和逻辑来决定最佳的继承策略。

#Unity #cSharp #dash #airstate #groundstate #playerstate #FSM

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-09-30-再講講為什麼要一個timer 來稿dash ,而不是直接給dash 設置一個時間，然後讓人物直接在時間短…

2023-09-30-再講講為什麼要一個timer 來稿dash ,而不是直接給dash 設置一個時間，然後讓人物直接在時間短哪move就行？

---

layout: post title: ‘再講講為什麼要一個timer 來稿dash ,而不是直接給dash 設置一個時間，然後讓人物直接在時間短哪move就行？’ date: 2023-09-30T14:56:53-04:00

---

使用一个计时器（timer）来控制dash的持续时间与直接为dash设置一个固定时间的主要区别在于你对dash动作的控制精细度和灵活性。

1. 更细粒度的控制:
   • 使用计时器，你可以在dash期间进行更精细的控制，例如在dash的一半时减速，或者在特定的时间点触发某些事件或效果。
2. 灵活性:
   • 如果你想在dash过程中允许玩家进行某些操作（例如中断dash或使用技能），计时器提供了这种能力。玩家可能在dash的一半时决定停止，或者游戏逻辑可能需要提前结束dash。
3. 更平滑的动画和反馈:
   • 通过每帧检查dash的状态，你可以更平滑地调整角色的动画或视觉效果。例如，你可能想要在dash开始时、中间时和结束时播放不同的动画或音效。
4. 额外的逻辑处理:
   • 你可能有一些逻辑需要在dash期间定期检查，例如检查玩家是否撞到墙壁、是否触碰到敌人或其他的障碍物。使用计时器，你可以在每次Update调用时执行这些检查。
5. 兼容性与代码清晰度:
   • 使用计时器方式与许多游戏引擎的主要Update循环模型相兼容，使得代码逻辑更加清晰和结构化。直接设置一个固定的时间可能需要额外的协程或异步逻辑，这可能会使代码更加复杂。

简而言之，虽然直接设置一个固定时间也是一种实现dash的方法，但使用计时器提供了更多的灵活性和控制精细度，允许更复杂和有趣的游戏机制的实现。

#Unity #cSharp #dash

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-09-30- if (moveDirection < 0 && transform.localScale.x > 0…

2023-09-30- if (moveDirection < 0 && transform.localScale.x > 0)為什麼這裡直接就可以訪問transform ，他不是unity裡面的一個屬性嗎？不需要player的代碼開頭import 嗎，或者想重新定義 component之類的

---

layout: post title: ‘ if (moveDirection < 0 && transform.localScale.x > 0)為什麼這裡直接就可以訪問transform ，他不是unity裡面的一個屬性嗎？不需要player的代碼開頭import 嗎，或者想重新定義 component之類的’ date: 2023-09-30T14:48:53-04:00

---

在 Unity 中，每一个继承自 MonoBehaviour 的脚本都可以直接访问 transform，因为 transform 是 MonoBehaviour 类的一个内置属性。所以你在脚本中不需要进行任何特殊的导入或获取组件的操作就可以直接访问它。

你的 Player 类（和大多数其他游戏对象的自定义脚本）很可能都是继承自 MonoBehaviour。因此，当你在这些脚本中使用 transform 时，你实际上是在访问这个脚本所附加的游戏对象的 Transform 组件。

简单来说，这是 Unity 提供给开发者的便利性设计，使我们能够更方便地访问和修改游戏对象的位置、旋转和缩放等属性。这也适用于其他内置属性，如 gameObject（用于访问脚本所附加的游戏对象本身）等。

#Unity #繼承 #cSharp

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-09-30-float moveDirection = Input.GetAxis(“Horizontal”); 為什麼…

2023-09-30-float moveDirection = Input.GetAxis(“Horizontal”); 為什麼不放在player代碼的開頭，而是要放在update函數裡面？ 有什麼講究嗎

---

layout: post title: ‘float moveDirection = Input.GetAxis(“Horizontal”); 為什麼不放在player代碼的開頭，而是要放在update函數裡面？ 有什麼講究嗎’ date: 2023-09-30T14:41:23-04:00

---

当你使用Input.GetAxis("Horizontal")这样的语句时，你实际上是在询问：“在当前这一帧，用户是否在水平方向上有任何输入？”因此，你需要在每一帧中都检查这个输入，以确保你能够捕获玩家的所有输入操作。

以下是为什么这个语句应该放在Update方法中的原因：

1. 每帧检查：Update函数在每一帧都会被调用。将输入检查放在Update中意味着你可以实时地捕获玩家的输入。这样，无论玩家何时按下或释放一个键，你都能够立即检测到并响应。

2. 实时反应：玩家的输入是动态的。他们可能在一帧内按下一个键，在下一帧释放它。如果你不在每一帧检查输入，你可能会错过这些瞬时的输入事件。

3. 变量的范围和生命周期：moveDirection变量的值会随玩家的输入而改变。如果你将其定义在Update外部（例如在类级别），那么它会有一个更长的生命周期，并且在不同的方法中都可以访问。在Update中为它分配值确保了其值是基于最新的玩家输入。

4. 代码清晰性：通常，我们希望Update方法能够清晰地表示在每一帧中发生了什么。将输入处理放在这里可以使其他开发者更容易理解每帧发生的事情。

简而言之，由于玩家的输入是动态的，并且可能在任何时候改变，所以你需要在每一帧都检查输入，而Update方法是实现这一点的最佳位置。

#Unity #variable #update #cSharp

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-09-30-為什麼在components裡的physics2的没有overlap circle 这个选项？ 代码里却…

2023-09-30-為什麼在components裡的physics2的没有overlap circle 这个选项？ 代码里却可以这么写？难道不是一一对应的吗

---

layout: post title: ‘為什麼在components裡的physics2的没有overlap circle 这个选项？ 代码里却可以这么写？难道不是一一对应的吗’ date: 2023-09-30T13:19:31-04:00

---

这是一个很好的问题，涉及到Unity如何将API和编辑器界面设计分开。让我解释一下：

1. Unity编辑器的Components菜单：
   • 在Unity编辑器的Components菜单中，你看到的通常是可以直接添加到GameObject上的组件。这些组件为游戏对象提供了特定的功能和行为。例如，Rigidbody2D和BoxCollider2D都是组件。
2. Unity的API：
   • Unity的API（通过C#脚本访问的）提供了一系列函数和方法，让开发者能够编程控制游戏的逻辑和行为。这些方法并不总是直接与编辑器中可见的组件相对应。
   • Physics2D.OverlapCircle是一个很好的例子。它是一个函数，不是一个组件，所以你不能直接从Components菜单中添加它到一个GameObject上。相反，你在脚本中调用这个函数来检查某个圆形区域是否与其他碰撞器重叠。
3. 为什么不一一对应？
   • Unity的设计是为了灵活性。编辑器提供了一套基本的工具和组件，使非程序员可以轻松地创建和设置游戏对象。然而，为了提供更高的灵活性和控制，Unity的API提供了一系列更高级和详细的功能，这些功能在编辑器中可能没有直接的等价物。

简而言之，Unity编辑器的Components菜单和Unity的API是两套不同的工具，它们有所重叠，但并不总是一一对应。编辑器是为了快速和直观地设置游戏对象，而API是为了编程和逻辑控制。

#Unity #physics2D

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-09-30-什么时候需要添加rigid body？ 还有collider

---

layout: post title: ‘什么时候需要添加rigid body？ 还有collider’ date: 2023-09-30T13:18:10-04:00

---

是的，你是对的。要在Unity中为GameObject启用2D物理交互，你需要给这个GameObject添加一个Rigidbody2D组件。只有当GameObject有Rigidbody2D组件时，它才会被2D物理引擎考虑为一个动态物体，能够与其他物理物体进行互动。

同时，Rigidbody2D也为GameObject提供了重力、力、扭矩等物理属性。如果没有它，即使你为GameObject添加了2D碰撞器（如BoxCollider2D或CircleCollider2D），该GameObject也不会与其他物体互动，因为它被视为一个静态的物理物体。

所以，总结一下：

• 如果你想让GameObject在2D物理世界中作为一个动态物体（例如，一个可以移动和与其他物体互动的玩家角色），你需要为它添加一个Rigidbody2D组件。

• 如果你只想让GameObject作为一个不动的障碍物（例如，一个墙或地面），那么只需要一个2D碰撞器就足够了，不需要Rigidbody2D组件。

希望这有助于你理解Unity中的2D物理系统！如果还有其他问题，请随时询问。

#Unity #Collider #RigidBody

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-09-30-if (isGrounded()) 為什麼isgrounded要加括號，

---

layout: post title: ‘if (isGrounded()) 為什麼isgrounded要加括號，’ date: 2023-09-30T13:09:30-04:00

---

在C#和许多其他编程语言中，isGrounded()带有括号是因为它是一个方法（method），而不是一个字段（field）或属性（property）。当你调用一个方法时，你需要使用括号，即使这个方法不接受任何参数。

如果你写isGrounded（不带括号），则你实际上是在引用方法本身，而不是调用它。这在某些情况下是有用的（例如，当你想把方法作为委托传递给其他方法时），但在大多数情况下，你实际上是想调用这个方法并获取它的返回值，因此你需要使用括号。

例如，如果你有以下的方法定义：

private bool isGrounded()
{
    // ... some logic to check if the player is on the ground ...
    return true; // or false, based on the logic
}

当你想调用这个方法时，你会这样写：

if (isGrounded())
{
    // Do something if the player is on the ground
}

这样，每次你调用isGrounded()方法时，它都会执行其中的逻辑，并返回一个布尔值，表示玩家是否在地面上。

#Unity #cSharp

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-09-30-transform和vector2區別

---

layout: post title: ‘transform和vector2區別’ date: 2023-09-30T13:07:12-04:00

---

Transform 和 Vector2 之间有很大的区别。让我们详细解释它们的功能和用途：

1. Transform:
   • 代表场景中的对象位置、旋转和缩放。
   • 它包含了position、rotation和scale三个主要的属性。在2D场景中，通常只关心position和scale。
   • 它也包含了关于对象在场景中的父子关系的信息。
   • 由于Transform是对象在Unity场景中的物理表示，因此它可以在Inspector中可视化和编辑。
2. Vector2:
   • 是一个数学结构，包含两个浮点数（x和y）。
   • 它通常用于表示2D空间中的点或方向。
   • 它没有rotation或scale信息，也没有任何与Unity场景层次结构相关的信息。

为什么使用Transform作为groundCheck而不是Vector2?

当你想要在Unity编辑器中可视化并轻松调整检测点的位置时，使用Transform作为groundCheck是有意义的。你可以创建一个空的GameObject作为玩家的子对象，并将其放在玩家的脚下。这样，你可以轻松地在场景中移动它来调整groundCheck的位置。

使用Transform还有另一个优点，那就是它会随着玩家对象的移动而移动。这意味着，即使你移动了玩家对象，groundCheck的位置也会保持相对不变。

而Vector2是一个静态的点。如果你想要一个固定的groundCheck点，并且不打算在场景中移动或调整它，那么使用Vector2也是可以的。但在大多数情况下，为了更大的灵活性和方便性，使用Transform是更好的选择。

#Unity #transform #Vector2

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-09-30-我这些代码应该放哪个class？ player吗，还是player state？还是grounds state…

2023-09-30-我这些代码应该放哪个class？ player吗，还是player state？还是grounds state？jumpstate

---

layout: post title: ‘我这些代码应该放哪个class？ player吗，还是player state？还是grounds state？jumpstate’ date: 2023-09-30T12:52:52-04:00

---

你的碰撞检测代码（如IsGrounded和IsTouchingWall方法）是玩家对象的基本属性和能力，因此通常最好将这些方法放在Player类中。这样，无论玩家处于何种状态，都可以轻松访问这些方法。

然后，你可以在各个状态类（如PlayerState, GroundState, JumpState等）中使用这些方法来决定转换到哪个状态或执行哪些操作。

例如：

• 在GroundState或PlayerIdleState中，你可能会使用IsGrounded方法来检查玩家是否还在地面上。如果玩家不再地面上（例如，他们走到了一个悬崖边缘），你可能会切换到AirState或FallState。

• 在JumpState中，你可能会使用IsTouchingWall来决定是否应该执行墙壁跳或墙壁滑行动作。

将这些方法放在Player类中可以确保它们在任何时候都可以被访问，并且保持了代码的整洁和模块化。这样，Player类会负责管理玩家的基本属性和行为，而状态类会根据这些属性和行为来决定具体的游戏逻辑。

总结一下：

• Player类：基本属性和能力（如位置、速度、是否接触地面等）。

• PlayerState类：玩家在特定时间所处的状态和该状态下的行为（如跳跃、走路、滑行等）。

通过这种分离，你可以更容易地管理和扩展你的代码，同时也使得玩家的行为和状态逻辑更加清晰。

#Unity #Player #FSM

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-09-29- 为什么jump button按下去这个代码要放在ground state这个class，而不是jumps…

2023-09-29- 为什么jump button按下去这个代码要放在ground state这个class，而不是jumps state ?

---

layout: post title: ‘ 为什么jump button按下去这个代码要放在ground state这个class，而不是jumps state ?’ date: 2023-09-29T23:05:27-04:00

---

这是因为跳跃的触发条件是基于玩家当前处于地面状态 (PlayerGroundedState)。在大多数游戏中，玩家只能在地面上起跳，所以检测跳跃输入（例如Input.GetButtonDown("Fire1")）最有逻辑的地方是在玩家处于地面状态的时候。

简单来说：

1. 当玩家在地面上时，我们处于PlayerGroundedState。
2. 在这个状态下，我们会不断检查玩家是否按下了跳跃按钮。
3. 如果玩家按下跳跃按钮，我们从PlayerGroundedState状态转换到PlayerJumpState状态，玩家开始起跳。

如果你将这段检测代码放在PlayerJumpState中，它不会有任何意义，因为当玩家已经在跳跃状态时，再次检测跳跃按钮就没有意义了。这就像说，当你已经在空中跳跃时，你通常不能再进行第二次跳跃（除非游戏支持双跳功能）。

因此，为了逻辑清晰和符合大多数游戏的玩家预期，跳跃的输入检测通常在地面状态中进行。

#Unity #jump

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-09-29-superstate的继承与管理

---

layout: post title: ‘superstate的继承与管理’ date: 2023-09-29T22:35:36-04:00

---

你引用的代码示例中的PlayerJumpState是从PlayerState派生的，这并不意味着跳跃状态在逻辑上不是地面状态的一部分。在你所提供的代码上下文中，PlayerState看起来像一个基础状态，所有其他玩家状态（如跳跃、行走、跑步等）都从这个基础状态派生。

从你之前提到的Superstate的讨论来看，我认为你可能混淆了两件事：

1. 代码继承：在你提供的代码中，PlayerJumpState从PlayerState继承。这意味着PlayerJumpState在代码上扩展了PlayerState的行为和属性。

2. 逻辑结构：在游戏的逻辑和设计上，跳跃状态确实可以被视为地面状态的一部分。但这并不意味着在代码中，PlayerJumpState必须直接从一个称为GroundState的类继承。

真正的问题是，如何在代码中表示和管理这些状态之间的关系。在Unity中，你可能使用Animator和它的状态机（StateMachine）来逻辑上组织这些状态。在Animator的状态机中，你确实可以有一个Ground的Superstate，其中包含诸如Idle、Walk、Run和Jump的子状态。

但在代码中，所有这些状态可能都会从一个共同的基类（如PlayerState）继承，因为它们可能都有一些共同的属性和行为。

总的来说，你所提到的PlayerState、PlayerJumpState等只是代码的表示。你在Animator中定义的状态机结构（使用Superstate和子状态）是这些状态如何在游戏的逻辑和设计中组织的表示。两者并不一定要一一对应。

#Unity #playerstate

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-09-29-private protected public

---

layout: post title: ‘private protected public’ date: 2023-09-29T17:23:34-04:00

---

在C#中，访问修饰符决定了变量或方法的可见性和可访问性。以下是常见的访问修饰符： • private: 该成员只能在其定义的类中访问。这是默认的访问级别。 • protected: 该成员可以在其定义的类中以及该类的派生类中访问。 • public: 该成员可以从任何位置访问，无论是否在同一个类或派生类中。在你给出的代码中，xInput 被声明为 protected，这意味着只有 PlayerState 类及其派生类可以访问它。如果你将 xInput 设置为 public，那么任何类都可以访问它，只要它们有一个 PlayerState 对象的引用或是 PlayerState 的一个派生类对象。

#Unity #cSharp #Private #Public #Protected #xInput

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-09-29-xbox手柄检测unity以及键位

---

layout: post title: ‘xbox手柄检测unity以及键位’ date: 2023-09-29T17:05:00-04:00

---

using UnityEngine;

public class XboxControllerTest : MonoBehaviour { void Update() { // 检测摇杆移动 float horizontal = Input.GetAxis(“Horizontal”); float vertical = Input.GetAxis(“Vertical”);

    if (horizontal != 0 || vertical != 0)
    {
        Debug.Log("摇杆输入: Horizontal = " + horizontal + ", Vertical = " + vertical);
    }

    // 检测ABXY按键
    if (Input.GetButtonDown("Fire1")) // 默认为A按键
    {
        Debug.Log("A 按钮被按下");
    }
    if (Input.GetButtonDown("Fire2")) // 默认为B按键
    {
        Debug.Log("B 按钮被按下");
    }
    if (Input.GetButtonDown("Fire3")) // 默认为X按键
    {
        Debug.Log("X 按钮被按下");
    }
    if (Input.GetButtonDown("Jump")) // 默认为Y按键
    {
        Debug.Log("Y 按钮被按下");
    }

    // 其他按键可以根据Unity的输入设置来继续添加
} }

#Unity #xboxController

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-09-29-Platform是否需要加collider和rigidbody

---

layout: post title: ‘Platform是否需要加collider和rigidbody’ date: 2023-09-29T16:31:32-04:00

---

如果你正在制作一个RPG动作类游戏，并且想知道平台（例如，玩家可以站上去的地面或平台）是否应该添加 Rigidbody 和 Collider，以下是一些建议：

1. Collider:
   • 是的，你应该为平台添加一个 Collider（或 Collider2D，如果你正在制作2D游戏）。这样，玩家和其他实体就可以与平台互动，例如站在其上或与其碰撞。
2. Rigidbody 或 Rigidbody2D:
   • 静态平台: 如果平台是静态的（不移动），那么通常不需要添加 Rigidbody。只需确保该平台有一个适当的 Collider，玩家和其他实体就可以与其互动。
   • 动态平台: 如果平台需要移动（例如，一个上下或左右移动的电梯），则需要添加一个 Rigidbody。在这种情况下，确保将 Rigidbody 设置为 Kinematic，这样它就不会受到物理力的影响，但仍可以通过脚本控制其移动。
   • 可互动平台: 如果玩家可以以某种方式推动或影响平台，那么平台应该有一个 Dynamic 的 Rigidbody。不过，在大多数RPG动作游戏中，大部分平台都是静态的或者是通过脚本控制的动态平台。

注意: 当使用 Rigidbody 为动态或可互动的平台时，确保平台的移动不会意外地推动或挤压玩家。你可能需要微调碰撞和物理参数，以实现理想的互动效果。

总结：为平台添加一个 Collider 是必要的。至于是否需要 Rigidbody，则取决于平台是否需要移动或与玩家进行某种特定的互动。

#Unity #cSharp #Collider #RigidBody

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-09-29-game里人物的运动

---

layout: post title: ‘game里人物的运动 ‘ date: 2023-09-29T16:28:18-04:00

---

gravity scale 是 Unity 的 Rigidbody2D 组件中的一个参数，它决定了物体受到的重力加速度。对于动作游戏，这个参数对角色的跳跃和下落的感觉有很大影响。

1. Gravity Scale:
   • 值为1：物体会按照默认的重力加速度下落。
   • 大于1：增加重力影响，物体下落更快。
   • 小于1但大于0：减少重力影响，物体下落更慢。
   • 值为0：物体不受重力影响，不会自动下落。

   在动作游戏中，你可能希望角色的跳跃和下落感觉更加有弹性或更具挑战性。通过调整 gravity scale，你可以实现这一效果。

2. 其他重要参数:

   • Mass (质量): 决定了物体的重量，影响碰撞时的物体反应。
   • Drag (阻力): 控制空气阻力，影响物体在空中的移动速度。
   • Angular Drag (角阻力): 控制旋转时的阻力。
   • Constraints (约束): 限制物体在某个方向的移动或旋转，例如，如果你不希望角色左右翻滚，可以固定Z轴的旋转。

对于动作类游戏，建议：

1. 调试重力，使角色的跳跃和下落感觉自然并符合游戏的节奏。
2. 如果角色在空中移动过快或过慢，调整阻力。
3. 如果角色的碰撞反应过于夸张，调整质量。

最后，实际的参数设置和调整需要根据游戏的具体需求和玩家的体验反馈进行。最好的做法是多次试验，找到最适合你游戏的设置。

#cSharp #Unity #Game #Gravity #Player

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-09-29-class和屬性的區別

---

layout: post title: ‘class和屬性的區別’ date: 2023-09-29T00:24:39-04:00

---

public class Weapon { public string Name { get; set; } public int Damage { get; set; } // …其他属性和行为 }

public class Player { public string PlayerName { get; set; } public Weapon EquippedWeapon { get; set; } // …其他属性和行为 }

#c#

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023 study permit 

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

我跟这个世界的连接又少了一点

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Brady listing 

braking light detection

 刹车灯检测

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

119 教室

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

table finish

1. 时间轴suchronizing gps 和video
   1. tail light
   2. integrated module in my platform
   3. tovdetech whether a signage is needed
   4. or embed into realtime maps of
   5. autonomiys vehicles to enhance safety and

• For instance, frequent tail light activations combined with reduced vehicle speeds in a specific zone might suggest the need for clearer signage, be it a speed limit indication or a warning sign.

1. Recommendation:
   • Based on the patterns discerned, the research will yield recommendations on where new traffic signs might be most impactful. These recommendations will be grounded in quantifiable data, ensuring that they address real-world, observed challenges.

Conclusion:

By merging diverse data streams, this research offers a data-driven approach to urban planning and road safety. With the current emphasis on tail light extraction, we’re tapping into a rich, yet often overlooked, source of insight into driver behavior, bringing us one step closer to safer and more efficient roadways.

車輛密度的增加可以從兩個數據源中獲得，但各有其優勢和限制：

1. 視頻數據：
   • 優勢：視頻數據可以直接提供車輛的視覺信息，使你能夠精確地計算特定區域或視野中的車輛數量。使用物體檢測算法（如YOLO或SSD）可以識別和計數車輛。
   • 限制：視頻數據的範圍受到攝像頭的視野和分辨率的限制。此外，如果車輛遠離攝像頭或被其他物體遮擋，則可能無法識別。
2. GPS數據：
   • 優勢：如果多輛車都裝有GPS裝置且數據可用，則可以計算特定區域的車輛密度。GPS數據可以提供大範圍的車輛位置信息，並且不受視覺障礙物的影響。
   • 限制：不是所有車輛都裝有GPS裝置，或者不是所有的GPS數據都可用。此外，GPS數據可能存在一定的誤差，尤其是在高樓大廈或隧道等區域。

綜上所述，車輛密度的增加通常更容易從視頻數據中獲得，因為它可以直接提供車輛的視覺信息。然而，GPS數據在提供大範圍的車輛位置信息方面也很有價值。最佳的方法可能是結合這兩種數據源，以獲得更全面和精確的車輛密度信息。

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

數據同步 當然可以。數據同步是確保多個數據源之間的數據在時間上保持一致的過程。在你的情境中，我們需要確保GPS數據和視頻數據在同一時間點是同步的。以下是一個具體的數據同步方法： 確定時間戳：

• 首先，確定GPS數據和視頻數據都有可靠的時間戳。對於GPS數據，這通常是內置的；對於視頻，你提到視頻下方有時間，這可以作為時間戳。

1. 時間校正：
   • 如果GPS和視頻數據的時間戳不完全匹配，你可能需要進行時間校正。這可以通過手動調整或使用自動校正算法來實現。
   • 例如，如果你知道視頻開始的確切時間和GPS數據的開始時間，你可以計算兩者之間的差異並相應地調整。
2. 數據插值：
   • 在某些情況下，GPS數據的頻率可能高於或低於視頻的幀率。在這種情況下，你可能需要使用插值方法來估計某些時間點的GPS數據。
   • 例如，如果GPS每秒提供一次位置更新，而視頻是30fps，則每幀之間的GPS位置可能需要通過線性插值或其他方法來估計。
3. 數據結合：
   • 一旦確保了時間的同步，你可以開始結合GPS和視頻數據。對於視頻的每一幀，都可以有一個相應的GPS位置和速度。
   • 這可以通過簡單的數據結構（如數據表或數據庫）來實現，其中每一行或每一條目都包含一個時間戳、視頻幀和相應的GPS數據。
4. 驗證同步：
   • 在完成同步後，進行驗證是很重要的。這可以通過視覺檢查（例如，查看視頻中的車輛位置與GPS數據是否匹配）或使用統計方法來實現。
5. 自動化同步：
   • 如果你頻繁地進行這種同步，考慮開發一個自動化的工具或腳本來簡化這一過程。

車輛密度的增加可以從兩個數據源中獲得，但各有其優勢和限制：

1. 視頻數據：
   • 優勢：視頻數據可以直接提供車輛的視覺信息，使你能夠精確地計算特定區域或視野中的車輛數量。使用物體檢測算法（如YOLO或SSD）可以識別和計數車輛。
   • 限制：視頻數據的範圍受到攝像頭的視野和分辨率的限制。此外，如果車輛遠離攝像頭或被其他物體遮擋，則可能無法識別。
2. GPS數據：
   • 優勢：如果多輛車都裝有GPS裝置且數據可用，則可以計算特定區域的車輛密度。GPS數據可以提供大範圍的車輛位置信息，並且不受視覺障礙物的影響。
   • 限制：不是所有車輛都裝有GPS裝置，或者不是所有的GPS數據都可用。此外，GPS數據可能存在一定的誤差，尤其是在高樓大廈或隧道等區域。

綜上所述，車輛密度的增加通常更容易從視頻數據中獲得，因為它可以直接提供車輛的視覺信息。然而，GPS數據在提供大範圍的車輛位置信息方面也很有價值。最佳的方法可能是結合這兩種數據源，以獲得更全面和精確的車輛密度信息。

從某輛數據採集車的內部拍攝的視頻數據中進行異常檢測，例如煞車燈突然亮起或車輛急遽減速，可以分為以下步驟：

1. 數據前處理：
   • 帧差異分析：計算連續視頻帧之間的差異，這有助於檢測物體的動態變化。
   • 背景消除：使用方法如背景模型化來移除靜態的背景，只留下動態物體。
2. 物件檢測：
   • 使用預先訓練的物件檢測模型，例如YOLO、SSD或Faster R-CNN，來檢測和分類車輛。
   • 適當地調整或再訓練模型，使其可以特別識別煞車燈。
3. 異常檢測：
   • 煞車燈檢測：一旦車輛被檢測到，可以進一步分析該車輛的尾部區域來檢測煞車燈。煞車燈亮起時，該區域的亮度和顏色可能會有明顯變化。
   • 急遽減速檢測：通過分析連續帧中車輛的位置，可以計算其速度和加速度。如果速度在很短的時間內大幅下降，這可能表示車輛正在急劇減速。
4. 訓練異常檢測模型：
   • 可以使用一組正常和異常的訓練樣本來訓練一個分類模型。
   • 使用方法如One-Class SVM、Isolation Forest或Autoencoders進行無監督異常檢測。
5. 後處理：
   • 設定閾值：例如，如果煞車燈在1秒內連續亮起，或車輛的速度在0.5秒內下降超過某一百分比，則認為是異常。
   • 濾波：使用時間窗口或滑動平均來消除偶然的誤檢或短暫的異常。
6. 實時應用：
   • 異常檢測系統可以部署到邊緣計算設備上，以實時分析從數據採集車內部拍攝的視頻。

注意：視頻質量、照明條件、其他車輛的類型和顏色都可能影響異常檢測的效果。因此，在實際部署前，建議對系統進行充分的測試和驗證。

要綜合這些數據（煞車燈亮起、車速、兩車距離）來進行綜合評估，您可以使用一些多變量的統計方法或機器學習模型來整合這些特徵。以下是一種可能的方法：

1. 特徵工程：

首先，您需要從原始數據中提取有用的特徵。

• 煞車燈亮起頻率：例如，每分鐘亮起次數。
• 平均車速和車速標準差：這可以反映車輛的平均速度和速度的穩定性。
• 車輛間的平均距離和距離標準差：這可以反映車流的密度和穩定性。

2. 建立一個評分系統：

給每個特徵分配一個權重，然後計算一個綜合得分。例如：

[ \text{Score} = w_1 \times \text{BrakeFrequency} + w_2 \times \text{AvgSpeed} + w_3 \times \text{AvgDistance} ]

其中 ( w_1 )、 ( w_2 ) 和 ( w_3 ) 是每個特徵的權重。

3. 使用機器學習：

如果您有標記的數據（例如，某些地方已經知道是否需要新的交通標誌），您可以使用機器學習模型來預測該地區是否需要新的交通標誌。

例如，您可以使用決策樹、隨機森林、支持向量機等模型。訓練模型時，輸入特徵是煞車燈亮起頻率、平均車速和車輛間的平均距離，而目標變量是該地區是否需要新的交通標誌。

4. 設定閾值：

無論是使用評分系統還是機器學習模型，都可以設定一個閾值，當得分或預測概率超過這個閾值時，認為該地區需要新的交通標誌。

5. 驗證和調整：

使用交叉驗證等方法評估您的模型或評分系統的性能。根據結果，對特徵、權重或模型參數進行調整，以達到最佳效果。

這只是一種綜合這些數據的方法。實際上，最佳方法取決於具體數據和業務目標。

Using tail light activation data, vehicle speed data, and inter-vehicle distance data to analyze whether a specific section of the highway requires new traffic signs or other measures is an excellent approach. These data can provide valuable insights into vehicle behaviors in the area.

Here’s a breakdown of how you might use these data for analysis:

1. Data Collection: First, you’ll need to gather all the necessary data. This may require advanced instruments, such as vehicle counters, speed sensors, and inter-vehicle distance calculators.

2. Data Preprocessing: Clean the data to eliminate any anomalies or errors. For example, filter out any aberrant speed or distance readings.

3. Analyze Tail Light Activation Frequency: Calculate the frequency of brake light activations at a particular location. Frequent braking might suggest vehicles often need to slow down at this spot.

4. Analyze Vehicle Speed: Determine the average speed of vehicles and the variability of speeds. If most vehicles are slowing down, it might suggest there’s some hazard at this place.

5. Analyze Inter-Vehicle Distance: Assess the average distance between vehicles. Short distances between vehicles might indicate high traffic density or short driver reaction times.

6. Result Evaluation: Based on the above analysis, decide whether the area needs new traffic signs or other measures. For instance, if most vehicles are slowing down and the inter-vehicle distance is short, there might be a need for warning or speed limit signs at that location.

7. Ongoing Monitoring: Continue to monitor traffic conditions in the area even after implementing improvements to ensure that these measures remain effective.

This analytical method can help determine whether specific safety measures need to be implemented at a particular location, offering data-backed support for deciding which measures are most likely to enhance traffic safety in the area.

要判斷車輛減速和短的車輛間距是否是由於路面隱患而非僅僅是交通擁堵，你可以考慮以下策略：

1. 時間分析：查看一天中不同時間的行為模式。如果車輛在非高峰時段也減速，那麼可能不僅僅是由於交通擁堵。

2. 流量分析：將經常剎車和短車距的時段與整體交通流量進行交叉參考。如果流量低但這些行為持續存在，則表明可能存在其他問題。

3. 相鄰區域比較：將問題區域的車輛行為與道路相鄰部分進行比較。如果只有特定區段出現這種模式，則可能表示存在局部隱患。

4. 尾燈亮起但不減速：如果煞車燈頻繁亮起但沒有相應的速度減少，可能表示駕駛員出於預防措施進行剎車，這表明可能存在潛在隱患。

5. 查看事故報告：檢查該區域是否有事故或幾乎發生事故的報告。較高的事故次數可以驗證需要增加安全措施的必要性。

6. 與駕駛員交流：有時候，直接的反饋也很有用。對該路段的經常性駕駛者進行調查或訪談，可以了解他們的駕駛經驗和行為原因。

7. 實地檢查：如果可能的話，直接對路面進行實地檢查可以幫助識別微妙的問題，如不平的路面、被遮擋的標誌、急轉彎或視野不佳的區域。

通過考慮這些因素並將其與你的煞車燈亮起數據、車速和車輛間距數據進行交叉參考，你可以更清晰地了解問題是否是由於真正的路面隱患還是僅僅是常規的交通擁堵。

Of course, here’s a revised and coherent version of your work summary:

---

Dear Professor,

I hope this message finds you well. I would like to update you on the progress I made this week:

1. Thesis Objectives: I have drafted a comprehensive table outlining the objectives of my thesis. This structure should provide a clearer trajectory of my research aims and anticipated milestones.

2. Tail Light Detection: I’ve been focusing on analyzing video data to discern instances when the brake lights of vehicles are activated. The objective is to use this as a surrogate marker indicating potential deceleration or halting of vehicles.

3. Vehicle Dynamics: Alongside, I’ve initiated an exploration into the speed and positional data of vehicles. My goal here is to gain deeper insights into vehicular behavior across various road conditions.

4. Video Data Utilization: I am delving into methodologies that leverage video feeds from moving cameras. This includes object detection and motion estimation techniques which I believe can significantly enhance the granularity of our analysis.

5. Road Curvature Analysis: Another aspect I’ve turned my attention to is understanding the influence of road curvature on driving patterns. I hypothesize this could be pivotal in pinpointing potential traffic hotspot zones.

6. Data Integration: Building on the aforementioned points, I am in the preliminary stages of conceptualizing a model or algorithm. This model would synthesize all these data points to reliably identify regions that are susceptible to traffic congestion or pose potential risks.

These are the main areas of focus over the past week. Your feedback and guidance would be instrumental in steering this research in the right direction.

Thank you for your time.

Warm regards,

[Your Name]

---

This revised version emphasizes clarity and ensures logical flow throughout the content.

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

In our modern transportation ecosystem, ensuring road safety and optimizing… In our modern transportation ecosystem, ensuring road safety and optimizing traffic flow are paramount. My research is geared towards addressing this by leveraging a holistic approach - integrating video, GPS data, and other vehicular parameters such as tail light activation, vehicle speed, traffic density, and following distances between vehicles.

Objective: The primary aim is to ascertain whether a specific location necessitates the installation of new traffic signage, thereby enhancing safety and traffic flow.

Methodology:

1. Data Collection:
   • Video Data: Utilizing high-resolution cameras strategically placed to capture vehicular behavior in specific zones of interest.
   • GPS Data: Collating positional information to pinpoint exact locations of the vehicular events, ensuring accuracy in geospatial analysis.
   • Vehicular Parameters: This encompasses vehicle speed, volume of traffic, and following distances, collected through a combination of camera analytics and embedded sensors in vehicles.
2. Tail Light Extraction (Current Focus):
   • A crucial component of this study is the detection of tail light activations. Tail lights serve as a preliminary indication of deceleration, potential stops, or changes in vehicular behavior.
   • I am currently harnessing advanced computer vision techniques to extract tail light information from the video data. This involves identifying the brightness surge typical of a tail light being activated, even in varied lighting conditions. Additionally, machine learning models are being trained to distinguish between ambient light changes and actual tail light activations.
3. Data Integration and Analysis:
   • Once all the datasets are prepared, they are integrated into a unified platform. Sophisticated algorithms then cross-reference these datasets to identify patterns or anomalies in vehicular behavior.
   • For instance, frequent tail light activations combined with reduced vehicle speeds in a specific zone might suggest the need for clearer signage, be it a speed limit indication or a warning sign.
4. Recommendation:
   • Based on the patterns discerned, the research will yield recommendations on where new traffic signs might be most impactful. These recommendations will be grounded in quantifiable data, ensuring that they address real-world, observed challenges.

Conclusion:

By merging diverse data streams, this research offers a data-driven approach to urban planning and road safety. With the current emphasis on tail light extraction, we’re tapping into a rich, yet often overlooked, source of insight into driver behavior, bringing us one step closer to safer and more efficient roadways.

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

1. Thesis Objectives: I have drafted a comprehensive table outlining…

2. Thesis Objectives: I have drafted a comprehensive table outlining the objectives of my thesis. This structure should provide a clearer trajectory of my research aims and anticipated milestones.

3. Tail Light Detection: I’ve been focusing on analyzing video data to discern instances when the brake lights of vehicles are activated. The objective is to use this as a surrogate marker indicating potential deceleration or halting of vehicles.

4. Vehicle Dynamics: Alongside, I’ve initiated an exploration into the speed and positional data of vehicles. My goal here is to gain deeper insights into vehicular behavior across various road conditions.

5. Video Data Utilization: I am delving into methodologies that leverage video feeds from moving cameras. This includes object detection and motion estimation techniques which I believe can significantly enhance the granularity of our analysis.

6. Road Curvature Analysis: Another aspect I’ve turned my attention to is understanding the influence of road curvature on driving patterns. I hypothesize this could be pivotal in pinpointing potential traffic hotspot zones.

7. Data Integration: Building on the aforementioned points, I am in the preliminary stages of conceptualizing a model or algorithm. This model would synthesize all these data points to reliably identify regions that are susceptible to traffic congestion or pose potential risks.

Research Overview: Analyzing the Need for New Traffic Signage through Multi-Modal Data Integration

In our modern transportation ecosystem, ensuring road safety and optimizing traffic flow are paramount. My research is geared towards addressing this by leveraging a holistic approach - integrating video, GPS data, and other vehicular parameters such as tail light activation, vehicle speed, traffic density, and following distances between vehicles.

Objective: The primary aim is to ascertain whether a specific location necessitates the installation of new traffic signage, thereby enhancing safety and traffic flow.

Methodology:

1. Data Collection:
   • Video Data: Utilizing high-resolution cameras strategically placed to capture vehicular behavior in specific zones of interest.
   • GPS Data: Collating positional information to pinpoint exact locations of the vehicular events, ensuring accuracy in geospatial analysis.
   • Vehicular Parameters: This encompasses vehicle speed, volume of traffic, and following distances, collected through a combination of camera analytics and embedded sensors in vehicles.
2. Tail Light Extraction (Current Focus):
   • A crucial component of this study is the detection of tail light activations. Tail lights serve as a preliminary indication of deceleration, potential stops, or changes in vehicular behavior.
   • I am currently harnessing advanced computer vision techniques to extract tail light information from the video data. This involves identifying the brightness surge typical of a tail light being activated, even in varied lighting conditions. Additionally, machine learning models are being trained to distinguish between ambient light changes and actual tail light activations.
3. Data Integration and Analysis:
   • Once all the datasets are prepared, they are integrated into a unified platform. Sophisticated algorithms then cross-reference these datasets to identify patterns or anomalies in vehicular behavior.
   • For instance, frequent tail light activations combined with reduced vehicle speeds in a specific zone might suggest the need for clearer signage, be it a speed limit indication or a warning sign.
4. Recommendation:
   • Based on the patterns discerned, the research will yield recommendations on where new traffic signs might be most impactful. These recommendations will be grounded in quantifiable data, ensuring that they address real-world, observed challenges.

Conclusion:

By merging diverse data streams, this research offers a data-driven approach to urban planning and road safety. With the current emphasis on tail light extraction, we’re tapping into a rich, yet often overlooked, source of insight into driver behavior, bringing us one step closer to safer and more efficient roadways.

研究概述：通過多模態數據整合分析新交通標誌的需求

在我們的現代交通生態系統中，確保道路安全和優化交通流量是至關重要的。我的研究旨在通過採用全面的方法來解決這一問題 - 整合視頻、GPS數據以及其他車輛參數，如尾燈啟動、車輛速度、交通密度和車輛之間的跟隨距離。

目的：主要目的是確定特定位置是否需要安裝新的交通標誌，從而提高安全性和交通流量。

方法論：

1. 數據收集：
   • 視頻數據：利用策略性地放置的高分辨率攝像機捕捉特定感興趣區域的車輛行為。
   • GPS數據：收集位置信息以精確定位車輛事件的確切位置，確保地理空間分析的準確性。
   • 車輛參數：這包括通過攝像機分析和車輛中的嵌入式傳感器組合收集的車輛速度、交通量和跟隨距離。
2. 尾燈提取 (當前重點)：
   • 這項研究的一個關鍵組件是檢測尾燈的啟動。尾燈作為車速減慢、潛在停車或車輛行為變化的初步指示。
   • 我目前正在利用先進的計算機視覺技術從視頻數據中提取尾燈信息。這涉及識別尾燈啟動時典型的亮度激增，即使在不同的光照條件下也是如此。此外，正在訓練機器學習模型來區分環境光變化和實際的尾燈啟動。
3. 數據整合和分析：
   • 一旦所有數據集都已準備好，它們會被整合到一個統一的平台上。然後使用精密的算法交叉引用這些數據集，以識別車輛行為中的模式或異常。
   • 例如，特定區域中頻繁的尾燈啟動加上車速減慢可能表示需要更清晰的標誌，可能是速度限制指示或警告標誌。
4. 建議：
   • 根據所識別的模式，研究將提供有關在哪裡新的交通標誌可能最具影響力的建議。這些建議將基於可量化的數據，確保它們應對真實世界中觀察到的挑戰。

結論：

通過合併多種數據流，這項研究為城市規劃和道路安全提供了一種數據驅動的方法。目前在尾燈提取上的重點，我們正在挖掘一個豐富而常常被忽視的駕駛行為的洞察來源，使我們更接近更安全、更高效的道路。·

將這項研究與自動駕駛汽車結合，可以從以下幾個方向進行：

1. 增強自動駕駛的預測能力：
   • 通過分析特定路段的交通流模式和異常，自動駕駛系統可以預測前方可能的情況（如突然的減速、頻繁的車輛停靠等），從而提前作出適當的反應。
2. 完善地圖信息與路況警告：
   • 如果某些路段被識別為可能需要增設交通標誌的地方，這些信息可以即時地反饋到自動駕駛汽車的地圖系統中，提供額外的警告或建議，增強自動駕駛的安全性。
3. 交通流量優化：
   • 根據研究的結果，自動駕駛汽車可以獲得特定地點的交通流量和車輛行為模式，從而調整自己的駕駛策略，例如選擇最佳的行駛路線或避開交通熱點。
4. 改進自動駕駛決策：
   • 知道哪些地方的尾燈啟動頻繁或車速突然減慢可以幫助自動駕駛系統更好地理解和解釋其他汽車的行為，從而作出更為合理和安全的駕駛決策。
5. 協助道路基礎設施改善：
   • 除了提供給自動駕駛汽車使用的信息，這項研究還可以幫助城市規劃部門或交通管理局了解哪些地方可能需要增加或改善交通基礎設施，從而更好地適應自動駕駛汽車的出現和增多。
6. 訓練和驗證：
   • 通過這項研究，我們可以獲得真實世界中的駕駛情境和挑戰，這些數據可以用於訓練和驗證自動駕駛汽車的算法和模型，確保其在實際道路條件下的效能和安全性。

總之，這項研究不僅可以提供實際道路上的駕駛行為數據，還可以增強自動駕駛汽車的預測和反應能力，為其提供更加豐富和實用的道路信息。

Combining this research with autonomous vehicles can be approached from the following angles:

1. Enhance Predictive Capabilities of Autonomous Vehicles:
   • By analyzing traffic flow patterns and abnormalities on specific road sections, autonomous driving systems can anticipate potential scenarios ahead (e.g., sudden deceleration, frequent vehicle stops) and respond in advance accordingly.
2. Refinement of Map Information & Road Condition Alerts:
   • If certain road sections are identified as possibly requiring additional traffic signage, this information can be instantly integrated into the autonomous car’s mapping system, providing extra alerts or suggestions, thereby boosting the safety of autonomous operations.
3. Optimization of Traffic Flow:
   • Based on the study’s findings, autonomous cars can gain insights into traffic flow and vehicle behavior patterns at specific locations, adjusting their driving strategies, such as selecting the optimal route or avoiding traffic hotspots.
4. Improving Autonomous Decision Making:
   • Knowing where tail lights are frequently activated or where speeds reduce suddenly can help the autonomous system better interpret and understand the behavior of other vehicles, leading to more rational and safe driving decisions.
5. Assisting in Infrastructure Enhancement:
   • Beyond informing autonomous vehicles, this research can aid city planning departments or traffic management agencies in identifying where to add or improve traffic infrastructure, better accommodating the rise and proliferation of autonomous vehicles.
6. Training and Validation:
   • With this research, real-world driving scenarios and challenges can be obtained, which can be used to train and validate algorithms and models for autonomous cars, ensuring their performance and safety under actual road conditions.

In summary, this research not only provides insights into driving behaviors on actual roads but also bolsters the predictive and responsive capabilities of autonomous vehicles, furnishing them with richer and more practical road information.

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

车牌 清晰一点

1. 车辆的异常行为检测
   1. 论文 prposal tjesis table objectives

下周二之前发给他 我要做什么 ◦

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

余额交易必须满足绑定手机令牌满15天，且开通社区市场功能。邮箱验证不行！ 1.打开提货网址 https://zxwangluo.steamrobot.me/codebalance 2.输入激活码和steam的交易链接/或选择账号密码自助提货 3.登录steam号，进入自己【库存】-【交易报价】-【回应报价】-接收报价 4.在DOTA2游戏库存中，上架出售该饰品，填写正确的收款金额。 5.等待机器人在5-30分钟内购买该饰品 steam新规，交易完成后余额会变成待处理，24小时后才可以使用 本次提货码卡号：阿根廷4000比索 36FzWvAsz3UBCHW

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

nickname for social club: Luckysouth Steam name: BlackAce

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

电脑更新：

1. 4 * 16 = 64 G

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

妈肚子又开刀了 说是切除了子宫和宫颈 还有很多瘤子 好担心 怕她死掉 我该怎么办

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

zhouxingnan2016@gmail.com

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-09-06-我的CSQ申請

---

layout: post title: ‘我的CSQ申請’ date: 2023-09-06T23:11:37-04:00

---

https://www.quebec.ca/en/immigration/sponsor-family-member/sponsoring-spouse-conjugal- partner/submitting-undertaking-application#c145542

hui A0546GF xingnan 0520BF hui A520BF

#CSQ #PR #材料

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-09-06-CSQ Spousal sponsership 申請

---

layout: post title: ‘CSQ Spousal sponsership 申請’ date: 2023-09-06T22:34:00-04:00

---

YouTube的網址可以參考： csq

The phrase “How to Apply for Quebec’s CSQ in Canada’s Spousal Sponsorship Application? STEP-BY-STEP GUIDE” appears to be a request for a step-by-step guide on how to include the Quebec Selection Certificate (CSQ) as part of a spousal sponsorship application in Canada. Here’s a simplified guide to help you understand the process:

1. Determine Eligibility: Ensure that both you (the sponsor) and your spouse (the sponsored person) meet the eligibility requirements for the spousal sponsorship program.

2. Quebec Selection Certificate (CSQ): Quebec has its own immigration selection process. If your spouse plans to live in Quebec, they will need to apply for a CSQ through the Quebec government’s immigration program, typically the Quebec Skilled Worker Program (QSWP).

3. Spousal Sponsorship Application: Begin the spousal sponsorship application process through Immigration, Refugees, and Citizenship Canada (IRCC). This involves completing the necessary forms, gathering supporting documents, and paying the application fees.

4. Indicate Quebec Intent: Within the spousal sponsorship application forms, you will need to indicate that your spouse intends to reside in Quebec. This informs IRCC that your spouse will apply for a CSQ.

5. Submit the CSQ Application: Simultaneously, your spouse should apply for the CSQ through the Quebec government’s immigration website. They will need to meet the specific requirements of the QSWP and submit the required documents.

6. Wait for CSQ Approval: Quebec will review the CSQ application and, if approved, issue the CSQ to your spouse. This is a mandatory step for Quebec-bound immigrants.

7. Continue with IRCC Application: Once the CSQ is obtained, continue with the spousal sponsorship application through IRCC. Provide proof of the CSQ in your application package.

8. Processing Time: Both the CSQ application and the spousal sponsorship application have their own processing times. Be prepared to wait for the decisions.

9. Medical and Security Checks: Your spouse will need to undergo medical and security checks as part of the IRCC application process.

10. Interview (if required): In some cases, IRCC may request an interview with you and your spouse to assess the genuineness of the relationship.

11. Decision and Landing: Once both applications are approved, your spouse will be issued a permanent resident visa. They can then land in Canada and become a permanent resident.

12. Reside in Quebec: After landing in Canada, if your spouse has obtained the CSQ, they should fulfill their commitment to reside in Quebec as indicated in their CSQ application.

Please note that immigration policies and processes may change over time, so it’s essential to consult the official websites of IRCC and the Quebec government for the most up-to-date information and application forms. Additionally, you may consider consulting with an immigration lawyer or consultant for personalized guidance through this process.

#CSQ #PR

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-09-06-PR 申請術語

---

layout: post title: ‘PR 申請術語’ date: 2023-09-06T22:21:09-04:00

---

首先，针对魁北克结婚担保PR相关的术语，以下是一些您可能会遇到的英文术语：

1. Sponsorship: 担保。在此上下文中，指的是一个加拿大公民或永久居民愿意担保其配偶或伴侣移民到加拿大。

2. Sponsor: 担保人。一位加拿大公民或永久居民，愿意担保其配偶或伴侣。

3. Principal Applicant: 主要申请人。在此上下文中，通常指的是被担保的配偶或伴侣。

4. Permanent Resident (PR): 永久居民。有权在加拿大长期居住的个人。

5. Quebec Selection Certificate (CSQ - Certificat de sélection du Québec): 魁北克选定证书。一个由魁北克省政府颁发的证书，表示该个人已获得魁北克的同意成为永久居民。

6. Undertaking: 承诺。担保人对政府的承诺，表示他们会在一定期限内为被担保者提供财务支持。

7. Inland Sponsorship: 国内担保。当主要申请人已经在加拿大境内时进行的担保。

8. Outland Sponsorship: 国外担保。当主要申请人在加拿大境外时进行的担保。

关于您想要的恋爱故事，我需要以下信息来创建：

1. 主角的名字和背景：例如他们的年龄、职业、性格特点、兴趣爱好等。
2. 故事的背景：例如地点、时代或任何特定的文化背景。
3. 您希望的故事的主题或中心冲突：例如是否有第三者、文化差异、距离挑战等。
4. 故事的结局：例如他们是否最终在一起，还是选择了各自的道路。

请提供这些信息，我将为您创作一个恋爱故事。

#PR

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-09-06-PR填寫表格

---

layout: post title: ‘PR填寫表格 ‘ date: 2023-09-06T21:52:23-04:00

---

很抱歉，由於我無法在實時瀏覽網頁，我無法直接提供您當前IRCC網站上的表格下載鏈接。但您可以輕鬆地訪問IRCC的官方網站，並在”Forms”或”Application Packages”部分尋找相應的表格。

然而，我可以提供一般性的指南和checklist。請注意，這只是基於我的最後的知識基礎（截止於2021年），具體信息和要求可能已經有所變化。

填寫表格的指南：

1. 基本信息: 確保填寫您的全名、出生日期、國籍、現在的地址等基本信息。
2. 關於您的家庭: 包括任何之前的婚姻、子女的信息等。
3. 您的居住和工作經歷: 列出您在過去的一些年份中的居住和工作地點。
4. 您和您的担保人的關系: 提供關於您和您配偶的詳細信息，包括你们是如何相识的、結婚日期等。

文件checklist：

1. 身份和關係文件:
   • 出生證明
   • 結婚證書
   • 之前的離婚證明或死亡證書（如適用）
2. 關係證明:
   • 聯名帳戶的賬單或其他財務文件
   • 共同的住址證明，如水電瓦斯帳單
   • 旅行或其他活動的照片
   • 亲朋好友的證明信
3. 財務文件:
   • 担保人的收入證明，例如工資單或報稅表

4. 醫療檢查: 通常，您需要從指定的醫療專家那裡進行醫療檢查。這些醫生是由加拿大政府授權的，具体的列表应该可以在IRCC的网站上找到。

5. 刑事紀錄證明: 如果您在其他國家住過6個月以上，您可能需要從那些國家獲得刑事紀錄證明。在加拿大，您可以向加拿大皇家騎警（RCMP）申請此證明。

由於您目前在加拿大留學，建議您訪問學校的國際學生服務中心。他們可能有專業的顧問可以為您提供更具體和最新的指導和建議。

#PR

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-09-06-PR擔保材料

---

layout: post title: ‘PR擔保材料’ date: 2023-09-06T21:47:55-04:00

---

當然可以。我將更詳細地解釋第二和第三部分：

第二部分：提交担保申请

1. 下载和填写申请表格：
   • 从IRCC的官方网站下载“担保配偶或伴侣”申请套件。
   • 该套件包含多个表格，包括担保人申请表、被担保人的永久居留权申请表以及其他相关表格。
2. 仔细阅读指南：
   • 申请套件通常都有一个详细的指南，指南中会解释如何填写每个表格以及需要提交的支持文件。
3. 填写所有必要的表格：
   • 确保所有表格都被正确填写，并由相应的申请人签名。

第三部分：收集并提交所需文件

1. 身份文件：
   • 出生证明；
   • 结婚证书（如果适用）；
   • 之前的离婚证明或死亡证书（如果适用）。
2. 关系证明：
   • 你们需要提供证明你们关系真实性的证据，这可能包括但不限于：
     • 共同的财务文件（例如联名银行帐户）；
     • 共同的住址证明；
     • 共同参与活动或旅行的照片；
     • 亲朋好友的证明信等。
3. 财务文件：
   • 你的配偶可能需要提供关于她的收入和财务状况的证明来证明她有能力担保你。
4. 医疗检查和刑事记录证明：
   • 你可能需要进行医疗检查并提供刑事记录证明来满足加拿大的健康和安全标准。
5. 支付费用：
   • 根据指南支付申请费。费用可能会随时间而变化，因此确保查看最新的费率。
6. 组合所有文件和表格：
   • 一旦你收集齐所有必要的文件和表格，按照指南的要求将它们组合在一起。
7. 提交申请：
   • 将完整的申请套件寄给指定的IRCC办公室。确保保留所有的复印件以及邮寄的证明。

请注意，这只是一个基本的概述，每个人的情况可能会有所不同。再次强调，为了确保申请的成功和遵循所有要求，建议查阅IRCC的官方网站或咨询移民律师。

#PR

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-09-06-tfliteyolov4檢測視頻，只檢測第一幀的修改

---

layout: post title: ‘tfliteyolov4檢測視頻，只檢測第一幀的修改 ‘ date: 2023-09-06T14:59:29-04:00

---

https://github.com/hunglc007/tensorflow-yolov4-tflite/issues/383

不用切換tf到低版本也可以運行。 也不用docker image

import time
import tensorflow as tf
physical_devices = tf.config.experimental.list_physical_devices('GPU')
if len(physical_devices) > 0:
    # tf.config.experimental.set_memory_growth(physical_devices[0], True)
     for gpu in physical_devices:
        tf.config.experimental.set_memory_growth(gpu, True)
from absl import app, flags, logging
from absl.flags import FLAGS
import core.utils as utils
from core.yolov4 import filter_boxes, decode, YOLO
from tensorflow.python.saved_model import tag_constants
from PIL import Image
import cv2
import numpy as np
# from tensorflow.compat.v1 import ConfigProto
# from tensorflow.compat.v1 import InteractiveSession

flags.DEFINE_string('framework', 'tf', '(tf, tflite, trt')
# flags.DEFINE_string('weights', './checkpoints/yolov4-416/variables/variables',
#                     'path to weights file')
flags.DEFINE_string('weights', './checkpoints/yolov4-416',
                    'path to weights file')
flags.DEFINE_integer('size', 416, 'resize images to')
flags.DEFINE_boolean('tiny', False, 'yolo or yolo-tiny')
flags.DEFINE_string('model', 'yolov4', 'yolov3 or yolov4')
flags.DEFINE_string('video', '../GPSvisualization/videos/no_shadow.mp4', 'path to input video')
flags.DEFINE_float('iou', 0.45, 'iou threshold')
flags.DEFINE_float('score', 0.25, 'score threshold')
flags.DEFINE_string('output', '../GPSvisualization/data/out_short.mp4', 'path to output video')
flags.DEFINE_string('output_format', 'XVID', 'codec used in VideoWriter when saving video to file')
flags.DEFINE_boolean('dis_cv2_window', False, 'disable cv2 window during the process') # this is good for the .ipynb


# @tf.function
def infer(batch_data, model):
    STRIDES, ANCHORS, NUM_CLASS, XYSCALE = utils.load_config(FLAGS)
    # batch_data = tf.constant(image_data)
    feature_maps = model(batch_data)
    bbox_tensors = []
    prob_tensors = []
    if FLAGS.tiny:
        for i, fm in enumerate(feature_maps):
            if i == 0:
                output_tensors = decode(fm, FLAGS.size // 16, NUM_CLASS, STRIDES, ANCHORS, i, XYSCALE,
                                        FLAGS.framework)
            else:
                output_tensors = decode(fm, FLAGS.size // 32, NUM_CLASS, STRIDES, ANCHORS, i, XYSCALE,
                                        FLAGS.framework)
            bbox_tensors.append(output_tensors[0])
            prob_tensors.append(output_tensors[1])
    else:
        for i, fm in enumerate(feature_maps):
            if i == 0:
                output_tensors = decode(fm, FLAGS.size // 8, NUM_CLASS, STRIDES, ANCHORS, i, XYSCALE,
                                        FLAGS.framework)
            elif i == 1:
                output_tensors = decode(fm, FLAGS.size // 16, NUM_CLASS, STRIDES, ANCHORS, i, XYSCALE,
                                        FLAGS.framework)
            else:
                output_tensors = decode(fm, FLAGS.size // 32, NUM_CLASS, STRIDES, ANCHORS, i, XYSCALE,
                                        FLAGS.framework)
            bbox_tensors.append(output_tensors[0])
            prob_tensors.append(output_tensors[1])

    pred_bbox = tf.concat(bbox_tensors, axis=1)
    pred_prob = tf.concat(prob_tensors, axis=1)
    if FLAGS.framework == 'tflite':
        pred_bbox = (pred_bbox, pred_prob)
    else:
        boxes, pred_conf = filter_boxes(pred_bbox, pred_prob, score_threshold=FLAGS.score,
                                        input_shape=tf.constant([FLAGS.size, FLAGS.size]))
        pred_bbox = tf.concat([boxes, pred_conf], axis=-1)
    boxes = pred_bbox[:, :, 0:4]
    pred_conf = pred_bbox[:, :, 4:]


    boxes, scores, classes, valid_detections = tf.image.combined_non_max_suppression(
        boxes=tf.reshape(boxes, (tf.shape(boxes)[0], -1, 1, 4)),
        scores=tf.reshape(
            pred_conf, (tf.shape(pred_conf)[0], -1, tf.shape(pred_conf)[-1])),
        max_output_size_per_class=50,
        max_total_size=50,
        iou_threshold=FLAGS.iou,
        score_threshold=FLAGS.score
    )
    return boxes, scores, classes, valid_detections

def main(_argv):
    # config = ConfigProto()
    # config.gpu_options.allow_growth = True
    # session = InteractiveSession(config=config)
    STRIDES, ANCHORS, NUM_CLASS, XYSCALE = utils.load_config(FLAGS)
    input_size = FLAGS.size
    video_path = FLAGS.video

    print("Video from: ", video_path )
    vid = cv2.VideoCapture(video_path)

    if FLAGS.framework == 'tflite':
        interpreter = tf.lite.Interpreter(model_path=FLAGS.weights)
        interpreter.allocate_tensors()
        input_details = interpreter.get_input_details()
        output_details = interpreter.get_output_details()
        print(input_details)
        print(output_details)
    else:
        # saved_model_loaded = tf.saved_model.load(FLAGS.weights, tags=[tag_constants.SERVING])
        # infer = saved_model_loaded.signatures[tf.saved_model.DEFAULT_SERVING_SIGNATURE_DEF_KEY]
        STRIDES, ANCHORS, NUM_CLASS, XYSCALE = utils.load_config(FLAGS)
        inputs = tf.keras.layers.Input([FLAGS.size, FLAGS.size, 3])
        outputs = YOLO(inputs, NUM_CLASS, FLAGS.model, FLAGS.tiny)
        model = tf.keras.Model(inputs, outputs)
        model.load_weights(FLAGS.weights)
    
    if FLAGS.output:
        # by default VideoCapture returns float instead of int
        width = int(vid.get(cv2.CAP_PROP_FRAME_WIDTH))
        height = int(vid.get(cv2.CAP_PROP_FRAME_HEIGHT))
        fps = int(vid.get(cv2.CAP_PROP_FPS))
        codec = cv2.VideoWriter_fourcc(*FLAGS.output_format)
        out = cv2.VideoWriter(FLAGS.output, codec, fps, (width, height))

    frame_id = 0
    while True:
        return_value, frame = vid.read()
        if return_value:
            frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
            image = Image.fromarray(frame)
        else:
            if frame_id == vid.get(cv2.CAP_PROP_FRAME_COUNT):
                print("Video processing complete")
                break
            raise ValueError("No image! Try with another video format")
        
        frame_size = frame.shape[:2]
        image_data = cv2.resize(frame, (input_size, input_size))
        image_data = image_data / 255.
        image_data = image_data[np.newaxis, ...].astype(np.float32)
        prev_time = time.time()

        if FLAGS.framework == 'tflite':
            interpreter.set_tensor(input_details[0]['index'], image_data)
            interpreter.invoke()
            pred = [interpreter.get_tensor(output_details[i]['index']) for i in range(len(output_details))]
            if FLAGS.model == 'yolov3' and FLAGS.tiny == True:
                boxes, pred_conf = filter_boxes(pred[1], pred[0], score_threshold=0.25,
                                                input_shape=tf.constant([input_size, input_size]))
            else:
                boxes, pred_conf = filter_boxes(pred[0], pred[1], score_threshold=0.25,
                                                input_shape=tf.constant([input_size, input_size]))
        else:
            batch_data = tf.constant(image_data)
            boxes, scores, classes, valid_detections = infer(batch_data, model)
        pred_bbox = [boxes.numpy(), scores.numpy(), classes.numpy(), valid_detections.numpy()]
        image = utils.draw_bbox(frame, pred_bbox)
        curr_time = time.time()
        exec_time = curr_time - prev_time
        result = np.asarray(image)
        info = "time: %.2f ms" %(1000*exec_time)
        print(info)

        result = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
        if not FLAGS.dis_cv2_window:
            cv2.namedWindow("result", cv2.WINDOW_AUTOSIZE)
            cv2.imshow("result", result)
            if cv2.waitKey(1) & 0xFF == ord('q'): break

        if FLAGS.output:
            out.write(result)

        frame_id += 1

if __name__ == '__main__':
    try:
        app.run(main)
    except SystemExit:
        pass

#yolov4 #tensorflow #videodetection

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

今天丫丫不见了 在楼下草丛里找了半个小时 把他找到 就在我们楼的正下方 找到她的瞬间哭了 以后再也不养猫 有软肋

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-08-30-Raspberry pi VPN setup 静态ip

---

layout: post title: ‘Raspberry pi VPN setup ‘ date: 2023-08-30T17:12:50-04:00

---

网址： https://youtu.be/rtUl7BfCNMY?si=OPIVyw7yWzGt-7s8

里面有个文本，可以跟着设置 每次要链接家里的网络，就可以用这个办法 IP iMac 77 MacBook 88 Raspberry pi 19 Windows A5000 100

#raspberrypi #VPN #wireguard #markdown

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-09-03-安卓刷機教程 Google pixel6a

---

layout: post title: ‘安卓刷機教程 Google pixel6a’ date: 2023-09-03T15:39:38-04:00

---

https://dacota.tw/blog/post/root-google-pixel-6-pro

https://github.com/chenxiaolong/BCR

#callrecording #unroot #刷機 #android

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-08-31-ipad玩LOL

---

layout: post title: ‘ipad玩LOL’ date: 2023-08-31T19:40:30-04:00

---

今天試了試用ipad遠程玩LOL 可以玩是可以玩 但是體驗特別不好 wasd鍵位都可以按 但是回程b 購物p 固定相機y 都不能響應 如果要讓他們工作，必須同時按住comman鍵⋯ 真是反人類 打遊戲已經很著急了 竟然還要按那麼多鍵 或許這個遊戲本來就不是設計來給人在ipad上遠程玩的⋯ 移動端的lol存在也有它的道理 是否能有人修改一下這個bug啊 如果網速跟得上的話 ipad真的是一個很輕便很好的選擇 出門在哪都能玩 多棒啊

#ipad #LOL #windows #遠程控制

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-08-31-windows家庭版打开远程控制

---

layout: post title: ‘windows家庭版打开远程控制’ date: 2023-08-31T17:33:23-04:00

---

https://blog.51cto.com/u_5139878/5426129Windows中文家庭版用户没有remote control的权限，这篇文章有介绍怎么做 有个特别奇怪的点 登录账户名字要输入xingnan才对 密码就是我的密码 为什么跟windows的界面不一样啊，奇了八怪的。 哎😑

#windows

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-08-31-要干的事

---

layout: post title: ‘要干的事’ date: 2023-08-31T05:17:09-04:00

---

看小红书 把cik的静态ip添加进去 包括两个苹果电脑 之后重启即可 自从把小红书的智能推荐关了 真的不沉迷了 推荐的内容贼难看 成功解救网瘾 发现steamlink 竟然能接收到本地的switch joy con的蓝牙信号 这些出门用我的vpn 带一个手柄 不就可以玩p5r吗？ 牛逼的

#随笔

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-08-31-PI上创建samba共享文件夹（创建文件服务器server）

---

layout: post title: ‘PI上创建samba共享文件夹（创建文件服务器server）’ date: 2023-08-31T02:43:09-04:00

---

要在树莓派上设置文件共享，并让MacBook可以访问共享的文件，你可以使用Samba（也称为SMB或CIFS）来创建一个文件共享服务器。以下是基本的步骤：

1. 安装Samba： 在树莓派上运行以下命令来安装Samba：

   sudo apt-get update
   sudo apt-get install samba
   

2. 配置Samba共享： 编辑Samba的配置文件以创建共享。运行以下命令来编辑配置文件：

   sudo nano /etc/samba/smb.conf
   

   在文件的末尾添加类似以下的配置来创建一个共享：

   [PiShare]
   comment=Raspberry Pi Shared Folder
   path=/path/to/shared/folder
   browseable=yes
   writeable=yes
   create mask=0777
   directory mask=0777
   public=no
   

   替换 /path/to/shared/folder 为你想要共享的实际文件夹路径。保存并关闭文件（在Nano中按 Ctrl + X，然后按 Y 确认保存）。

3. 创建Samba用户： 创建一个Samba用户，并将其添加到Samba用户数据库中。

   sudo smbpasswd -a pi
   

   这会提示你设置Samba用户的密码。

4. 重启Samba服务： 重启Samba服务以应用配置更改。

   sudo systemctl restart smbd
   

5. 从MacBook访问共享： 打开Finder，然后在菜单栏中选择 “前往” > “连接服务器”。在弹出窗口中，输入 smb://树莓派的IP地址/PiShare，然后点击”连接”。你可能需要提供Samba用户的凭据（用户名和密码）。

此时，你应该能够在MacBook上访问树莓派共享的文件夹。请注意，树莓派和MacBook都必须在同一局域网中，而且你需要在路由器或防火墙上允许Samba流量。

确保采取安全措施，如设置强密码、限制共享权限等，以保护共享的文件安全性。

#PI #SERVER #SMBA #samba

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-08-30-Router 登陆

---

layout: post title: ‘Router 登陆’ date: 2023-08-30T14:07:15-04:00

---

路由器登录网址： 192.168.1.1 username：user password：cikvoip

#router #ip

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-08-29-chatgpt说福原爱是柯文哲老婆

---

layout: post title: ‘chatgpt说福原爱是柯文哲老婆’ date: 2023-08-29T02:01:04-04:00

---

Q 福原爱是谁 简短回答 CHATGPT 福原爱（Fukuhara Ai）是一位著名的日本乒乓球运动员。 xZ Q 她老公是谁 简短回答 ⑤ CHATGPT 福原爱的丈夫是台湾的台北市长柯文哲（Ko Wen-je）。 为什么是柯文哲 ⑤ CHATGPT 福原爱和柯文哲结婚是因为他们相爱并决定一起生活。婚姻是个人选择，不一定需要特别的原因。 Message

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-08-29-chatgpt说福原爱老公是柯文哲

---

layout: post title: ‘chatgpt说福原爱老公是柯文哲’ date: 2023-08-29T02:00:05-04:00

---

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-08-28-Tt

---

layout: post title: ‘Tt ‘ date: 2023-08-28T23:33:55-04:00

---

 your data on a geo map and for that, several packages can take care of it, as GeoPandas for example. You can learn how to use GeoPandas, reading my article: How Safe are the Streets of Santiago. Sometimes install Geopandas packages can be complicated, depending on what environment you are working. Or, simplesly you need take the control seat of your code! So, on this article we will explore on “the hard way”, how to construct our own “geo map functions”, using “Shapefiles” and basic Python libraries.

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

11:24 PM Mon Aug 28 It called to me from my pocket, the way the King called Bilbo Baggins. My moment of clarity happened in my living room. I was sitting on the floor one evening, building train tracks with my kids, when my older son said: 1 ¾ 74% Dad, why are you looking at your phone? He wasn’t trying to make me feel bad or anything. He was just curious. But I didn’t have a good answer. So why was I looking at my iPhone? I didn’t even remember taking it out — it had sort of materialized in my hand. All day, I’d been looking forward to spending time with my kids, and now that it was finally happening, I wasn’t really there at all. I froze for a second. I thought back. When the iPhone came out, in 2007, it was shiny and beautiful and cool and I flat out wanted one. But I needed a justification,

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-08-28–rf

-rf 是命令行中的一個選項，它用於刪除文件和目錄。這個選項有兩部分：

• -r：表示遞歸（recursive），它會遞歸地刪除目錄及其內容，包括所有子目錄和文件。
• -f：表示強制（force），它會強制刪除文件或目錄，而不會提示確認。

因此，當你在命令行中使用 -rf 選項時，它會刪除目標文件或目錄以及其內容，而且不會提示確認，這是一個具有破壞性的操作，需要謹慎使用。

#cml

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-08-28-raspberrypi 使用靜態IP（Wi-Fi的連結）

設置 Raspberry Pi 的靜態 IP 地址與有線連接和無線連接的過程基本相同。以下是在 Raspberry Pi 上使用 WiFi 設置靜態 IP 地址的步驟：

1. 查看 WiFi 接口名稱： 首先，使用以下命令查看你的 WiFi 接口名稱（通常為 wlan0）：

   ifconfig
   

2. 編輯 dhcpcd.conf 文件： 在終端機中，使用以下命令編輯 dhcpcd.conf 文件：

   sudo nano /etc/dhcpcd.conf
   

3. 添加靜態 IP 配置： 在 dhcpcd.conf 文件的底部，添加以下類似的配置，以指定靜態 IP 地址、網關、DNS 等信息。請將以下示例配置替換為你的網絡信息：

   interface wlan0
   static ip_address=192.168.1.100/24
   static routers=192.168.1.1
   static domain_name_servers=192.168.1.1
   

   記得將 wlan0 替換為你的 WiFi 接口名稱，並根據你的網絡配置填寫正確的值。

4. 保存並退出編輯器： 按下 Ctrl + X 鍵，然後按下 Y 鍵確認保存，然後按下 Enter 鍵退出編輯器。

5. 重新啟動 Raspberry Pi： 使用以下命令重新啟動 Raspberry Pi，使新的靜態 IP 配置生效：

   sudo reboot
   

6. 確認 IP 地址： 重新啟動後，使用以下命令確認 Raspberry Pi 是否使用了指定的靜態 IP 地址：

   ip addr show wlan0
   

請根據你的 WiFi 網絡配置和需求進行相應的修改。設置靜態 IP 地址可以確保 Raspberry Pi 在每次啟動時都使用相同的 IP 地址，從而更容易進行遠程連接和管理。

#raspberrypi #ip 

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-08-28-調用棧callstack

“Call stack”（调用栈）是指在程序执行过程中用于跟踪函数调用的一种数据结构。当一个函数被调用时，它会在调用栈中创建一个新的栈帧（stack frame）来存储函数的局部变量、参数和返回地址等信息。当函数执行完成后，它的栈帧会被弹出，控制权回到调用该函数的地方。

调用栈的工作方式类似于堆叠盘子：当你放置一个新的盘子时，它会放在盘子堆的顶部；当你从堆顶移除盘子时，它会暴露下面的一个盘子。调用栈同样记录了函数的调用顺序，以及每个函数在何处被调用。

当代码中存在多个函数嵌套调用时，调用栈非常有用，它可以追踪函数之间的关系，以及在程序执行期间每个函数的状态。如果在函数中发生错误或异常，调用栈可以帮助您确定错误发生的位置，以及在调用栈中的哪个函数中出现了问题。

调用栈也可以用于递归函数的实现，因为递归函数会多次调用自身，而每次调用都会创建一个新的栈帧。

总之，调用栈是程序执行期间用于管理函数调用和跟踪执行流程的重要数据结构。

#callstack

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-08-28-vscode 波浪線

在 Visual Studio Code (VS Code) 中，波浪线（wavy underline）通常用于表示代码中的问题或警告。波浪线的颜色和样式可能因问题类型而异，但它们都是用来提醒您注意代码中的一些可能需要关注或修复的地方。

不同类型的波浪线和其含义如下：

1. 红色波浪线： 红色的波浪线通常表示编译错误或语法错误。这意味着代码中存在语法问题，可能会导致代码无法正确编译或执行。

2. 黄色波浪线： 黄色的波浪线通常表示警告。这可能是一些代码中的潜在问题或不推荐的做法，但不会阻止代码的编译和运行。

3. 蓝色波浪线： 蓝色的波浪线通常表示建议性的提示。这可能是一些代码中的优化建议或更好的实践。

4. 绿色波浪线： 绿色的波浪线通常表示提示信息，如变量未使用等。

波浪线的出现通常是由于 VS Code 内置的代码分析工具或安装的插件检测到了代码中的问题。点击波浪线上的小图标，您可以查看问题的详细信息，以及可能的修复建议。

总之，波浪线是 VS Code 中的一个重要视觉指示，帮助您更轻松地发现和解决代码中的问题，以提高代码的质量和可读性。

#vscode #tools

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-08-24-Google maps api 怎麼通過gps定位信息獲取那個路段的車道信息

要通過 Google Maps API 獲取特定路段的車道信息，您可以使用 Google Places API 或 Google Roads API 來實現。以下是一個簡單的示例，演示如何使用 Google Roads API 獲取指定經緯度坐標的車道信息：

1. 首先，您需要申請 Google Maps API 密鑰。您可以訪問 Google Cloud Console（https://console.cloud.google.com/）並創建一個專案，然後啟用 Google Roads API 並生成一個 API 密鑰。

2. 使用生成的 API 密鑰，您可以使用 Google Roads API 來獲取車道信息。以下是一個示例 Python 代碼，使用 requests 库發送請求：

import requests

API_KEY = 'YOUR_GOOGLE_API_KEY'
BASE_URL = 'https://roads.googleapis.com/v1/nearestRoads'

def get_lane_info(latitude, longitude):
    params = {
        'points': f'{latitude},{longitude}',
        'key': API_KEY
    }
    
    response = requests.get(BASE_URL, params=params)
    data = response.json()
    
    if 'snappedPoints' in data:
        for point in data['snappedPoints']:
            print("Place ID:", point['placeId'])
            print("車道數量:", point['metadata']['speedLimit']['lanes'])

latitude = 37.7749  # 經度
longitude = -122.4194  # 緯度

get_lane_info(latitude, longitude)

請將 'YOUR_GOOGLE_API_KEY' 替換為您的 Google Maps API 密鑰。這個示例中的 get_lane_info 函數將根據輸入的經緯度坐標獲取最近的路段信息，包括車道數量。

請注意，使用 Google Maps API 時需要遵守他們的使用政策和付費規則。根據您的需求，您可能需要進一步詳細了解 Google Roads API 的相關參數和功能。

#googlemapAPI #gps #車道 #限速 #GoogleroadsAPI

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-08-24-把GPS的信息和道路上的車道標誌標線一起顯示

要將 GPS 的信息和道路上的車道標誌、標線一起顯示，您需要獲取道路的地理信息數據（如經緯度坐標）並將其與 GPS 數據進行匹配。一般情況下，您可以使用地圖數據供應商提供的 API 或數據來源，獲取道路的地理信息。

以下是一個簡單的示例，使用 Folium 和 Python 來顯示 GPS 數據和道路標誌的連接。假設您有道路地理數據和 GPS 數據：

import folium
from folium.plugins import MarkerCluster

# 創建 Folium 地圖
m = folium.Map(location=[25.0, 120.0], zoom_start=10)

# 假設您有一個包含 GPS 數據的列表
gps_data = [
    {"time": "2023-08-01 08:00:00", "latitude": 25.0, "longitude": 120.0},
    {"time": "2023-08-01 09:00:00", "latitude": 25.1, "longitude": 120.1},
    # ...
]

# 假設您有一個包含道路地理信息的列表
road_data = [
    {"road_name": "Main Street", "latitude": 25.0, "longitude": 120.0},
    {"road_name": "Second Avenue", "latitude": 25.1, "longitude": 120.1},
    # ...
]

# 將 GPS 數據和道路地理信息轉換為 MarkerCluster
gps_cluster = MarkerCluster().add_to(m)
road_cluster = MarkerCluster().add_to(m)

for point in gps_data:
    folium.Marker([point["latitude"], point["longitude"]],
                  popup=point["time"]).add_to(gps_cluster)

for road in road_data:
    folium.Marker([road["latitude"], road["longitude"]],
                  icon=folium.Icon(color="green"),
                  popup=road["road_name"]).add_to(road_cluster)

# 顯示地圖
m.save("gps_and_road_map.html")

在此示例中，我們使用 Folium 的 MarkerCluster 來將 GPS 數據和道路地理信息分別添加到地圖上，並使用不同的圖標樣式來區分它們。您可以根據您的實際數據格式和需求進行調整和擴展。同時，如果您有道路標誌、標線的圖像，您也可以考慮使用 Folium 的自定義圖標來顯示它們。

#gps #道路標誌 #visualization #folium

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-08-24-folium建立GPS的可視位置

要顯示一段時間內的 GPS 數據，您可以使用 Python 的地理信息庫（如 Folium）來創建互動地圖，將多個位置點按照時間順序連接起來。這樣可以顯示一個時間軸上的軌跡，更好地呈現移動的軌跡。

以下是一個使用 Folium 來顯示一段時間內 GPS 數據的示例代碼：

import folium
from folium.plugins import TimestampedGeoJson

# 假設您有一個包含時間和經緯度的數據列表
gps_data = [
    {"time": "2023-08-01 08:00:00", "latitude": 25.0, "longitude": 120.0},
    {"time": "2023-08-01 09:00:00", "latitude": 25.1, "longitude": 120.1},
    # ...
]

# 創建 Folium 地圖
m = folium.Map(location=[25.0, 120.0], zoom_start=10)

# 將數據轉換為 GeoJSON 格式
geojson_data = {
    "type": "FeatureCollection",
    "features": []
}

for point in gps_data:
    feature = {
        "type": "Feature",
        "geometry": {
            "type": "Point",
            "coordinates": [point["longitude"], point["latitude"]],
        },
        "properties": {
            "time": point["time"]
        }
    }
    geojson_data["features"].append(feature)

# 將 GeoJSON 數據添加到地圖上並使用 TimestampedGeoJson 顯示時間軸
TimestampedGeoJson(geojson_data, period="PT1H", add_last_point=True).add_to(m)

# 顯示地圖
m.save("gps_trajectory_map.html")

在此示例中，我們使用了 Folium 的 TimestampedGeoJson 插件，將每個時間點的經緯度添加到地圖上，同時在地圖上顯示時間軸，讓您可以按照時間查看數據的軌跡。

這只是一個簡單的示例，您可以根據您的實際需求和數據格式進行調整和擴展。

#gps #folium

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-08-24-小數度 = 度 + (分 / 60) + (秒 / 3600) 為什麼度跟分分秒有關係？

这涉及到角度的度分秒制表示法，通常用于测量角度的方式。在这个表示法中，一个角度被分成度（°）、分（’，分钟）和秒（’‘，秒）三个部分。

1 度（°）等于 60 分（’），也等于 3600 秒（’‘）。 1 分（’）等于 60 秒（’‘）。

因此，使用度分秒制，一个角度的度部分加上分部分除以 60，再加上秒部分除以 3600，就可以得到以度为单位的小数度。这种表示法可以用来更精确地表示一个角度的大小，特别是在航海、天文学等领域。

#轉換 #gps #數據

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-08-24-45 deg 30’ 14.00” N 45.5038888888889, -73.6694027777778…

2023-08-24-45 deg 30’ 14.00” N 45.5038888888889, -73.6694027777778 怎麼計算的

您提供的座標 “45 deg 30’ 14.00” N” 是一個地理坐標，表示緯度。緯度是用來測量地球上某一點距離赤道的角度。

這個坐標的格式是度分秒 (DMS) 格式，可以分解成以下幾部分：

• 度 (degrees): 45 度
• 分 (minutes): 30 分
• 秒 (seconds): 14.00 秒
• 方向 (N): 表示北緯

要將這個度分秒表示轉換為小數度 (decimal degrees)，可以使用以下公式： 小數度 = 度 + (分 / 60) + (秒 / 3600)

換算這個例子中的緯度： 小數度 = 45 + (30 / 60) + (14.00 / 3600) = 45.5038888888889

同樣地，您提供的座標 “-73.6694027777778” 是一個小數度表示的經度。

所以，45 deg 30’ 14.00” N 的緯度為約 45.5038888888889，經度為約 -73.6694027777778。這些數值用來表示地球上的一個特定位置。

#gps #公式 #經緯度

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-08-24-为什么人长大了后就文艺不起来了

人长大后文艺情感可能不再那么突出的原因有很多，以下是一些可能的解释：

1. 责任和压力增加：随着年龄的增长，人们通常面临更多的责任和生活压力，如工作、家庭、金钱等。这些压力可能使他们难以有足够的时间和精力去追求文艺爱好。

2. 社会期望：社会往往对成年人有更多的期望，他们可能会感到需要更多地关注事业和家庭，而不是文艺创作或表现。

3. 客观限制：一些文艺爱好可能需要更多的身体活动或灵感，而随着年龄的增长，身体健康可能会有所下降，这可能会影响到文艺创作的能力。

4. 兴趣演变：随着时间的推移，个人的兴趣和价值观可能会发生变化。人们可能会发现他们对其他活动或兴趣产生了更大的兴趣，这可能会导致他们不再那么活跃地追求文艺爱好。

然而，不要忘记，无论年龄如何，文艺情感都可以通过适当的时间管理和坚持不懈来保持。重要的是找到平衡，继续追求和发展你的文艺爱好，无论你的年龄如何。

#blog #个人感悟

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-08-24-从手机上写博客推送github

今天我要发博客1 这条博可是我在手机上写的 我想试试能不能发出 原来blink shell还能直接连接raspberry pi的file dir 那是不是文件就能直接拉取传输了呢！

#github

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-08-24-测试博客

ssh pi@192.168.1.30 ‘cd ~/Documents/Jynxzzz.github.io/_posts; git status; git add . ; git commit -m “bb”; git push’

#blog

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-08-24

ssh pi@192.168.1.30 ‘cd ~/Documents/Jynxzzz.github.io/_posts; git status; git add . ; git commit -m “bb”; git push’

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-08-24

ssh pi@192.168.1.30 ‘cd ~/Documents/Jynxzzz.github.io/_posts; git status; git add . ; git commit -m “bb”; git push’

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-08-24 - 测试

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-08-24 测试博客

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

2023-08-24, 05:19 我要写博客1

测试

#blog

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

iPad写GitHub博客并推送，结合blinkshell

1. 在notes记录
   1. share到bear里面
   2. 从bear可以export到markdown格式，存储到blink shell。
   3. 运行shortcuts 是ssh raspberry pi ，选取blink shell里面_posts的那篇文章
   4. Paste 1 （更改文章格式，加日期，文件从iPad到raspberry的传输scp）
   5. Paste 2（GitHub的推送，这里只能用ssh克隆repo，不能http，否则登录不上github）
   6. Git status
   7. Git add .
   8. Git commit -m “message”
   9. Git push

      ssh 可以一次性运行多条command， 中间用；隔开即可。详情见shortcuts ssh raspberry pi

主要逻辑是要先把文件放在blink shell里面。因为paste1 的路径是blinkshell的路径。希望blinkshell能在iphone和Mac上同步。

#github #blinkshell #blog #ssh #raspberrypi

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

raspberrypi login

your_pi_ip 替換為 Raspberry Pi 的 IP 地址

查看user name： hostname -I

地址： pi@192.168.1.30

#raspberry_pi #login #remote_control #ssh #… 

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

pandoc template

\documentclass[$if(fontsize)$$fontsize$,$endif$$if(lang)$$lang$,$endif$$if(papersize)$$papersize$,$endif$]{$documentclass$}
\def\tightlist{}
\usepackage{booktabs}
\usepackage{geometry} 		% 設定邊界

\usepackage{listings} % 引入程式碼顯示套件
\usepackage{xcolor}   % 引入顏色套件

% 自定義程式碼塊樣式
\lstdefinestyle{mystyle}{
  backgroundcolor=\color{black}, % 設定背景顏色為淺灰色
  basicstyle=\color{white}\ttfamily,  % 設定基本字體顏色為黑色
  breaklines=true,
  language=,
  frame=none,
  numbers=left,     % 添加行號
  numberstyle=\tiny % 設定行號字體
}

% 使用自定義樣式
\lstset{style=mystyle}

\geometry{
  top=1in,
  inner=1in,
  outer=1in,
  bottom=1in,
  headheight=3ex,
  headsep=2ex
}
\usepackage[T1]{fontenc}
\usepackage{lmodern}
\usepackage{amssymb,amsmath}
\usepackage{ifxetex,ifluatex}
\usepackage{fixltx2e} % provides \textsubscript
% use upquote if available, for straight quotes in verbatim environments
\IfFileExists{upquote.sty}{\usepackage{upquote}}{}
\ifnum 0\ifxetex 1\fi\ifluatex 1\fi=0 % if pdftex
  \usepackage[utf8]{inputenc}
$if(euro)$
  \usepackage{eurosym}
$endif$
\else % if luatex or xelatex
  \usepackage{fontspec} 	% 允許設定字體
  \usepackage{xeCJK} 		% 分開設置中英文字型
  \setCJKmainfont{Hannotate TC} 	% 設定中文字型
  \setmainfont{Georgia} 	% 設定英文字型
  \setromanfont{Georgia} 	% 字型
  \setmonofont{Courier New}
  \linespread{1.2}\selectfont 	% 行距
  \XeTeXlinebreaklocale "zh" 	% 針對中文自動換行
  \XeTeXlinebreakskip = 0pt plus 1pt % 字與字之間加入0pt至1pt的間距，確保左右對整齊
  \parindent 0em 		% 段落縮進
  \setlength{\parskip}{20pt} 	% 段落之間的距離
  \ifxetex
    \usepackage{xltxtra,xunicode}
  \fi
  \defaultfontfeatures{Mapping=tex-text,Scale=MatchLowercase}
  \newcommand{\euro}{€}
$if(mainfont)$
    \setmainfont{$mainfont$}
$endif$
$if(sansfont)$
    \setsansfont{$sansfont$}
$endif$
$if(monofont)$
    \setmonofont{$monofont$}
$endif$
$if(mathfont)$
    \setmathfont{$mathfont$}
$endif$
\fi
% use microtype if available
\IfFileExists{microtype.sty}{\usepackage{microtype}}{}
$if(geometry)$
\usepackage[$for(geometry)$$geometry$$sep$,$endfor$]{geometry}
$endif$
$if(natbib)$
\usepackage{natbib}
\bibliographystyle{plainnat}
$endif$
$if(biblatex)$
\usepackage{biblatex}
$if(biblio-files)$
\bibliography{$biblio-files$}
$endif$
$endif$
$if(listings)$
\usepackage{listings}
$endif$
$if(lhs)$
\lstnewenvironment{code}{\lstset{language=Haskell,basicstyle=\small\ttfamily}}{}
$endif$
$if(highlighting-macros)$
$highlighting-macros$
$endif$
$if(verbatim-in-note)$
\usepackage{fancyvrb}
$endif$
$if(tables)$
\usepackage{longtable}
$endif$
$if(graphics)$
\usepackage{graphicx}
% We will generate all images so they have a width \maxwidth. This means
% that they will get their normal width if they fit onto the page, but
% are scaled down if they would overflow the margins.
\makeatletter
\def\maxwidth{\ifdim\Gin@nat@width>\linewidth\linewidth
\else\Gin@nat@width\fi}
\makeatother
\let\Oldincludegraphics\includegraphics
\renewcommand{\includegraphics}[1]{\Oldincludegraphics[width=\maxwidth]{#1}}
$endif$
\ifxetex
  \usepackage[setpagesize=false, % page size defined by xetex
              unicode=false, % unicode breaks when used with xetex
              xetex]{hyperref}
\else
  \usepackage[unicode=true]{hyperref}
\fi
\hypersetup{breaklinks=true,
            bookmarks=true,
            pdfauthor={$author-meta$},
            pdftitle={$title-meta$},
            colorlinks=true,
            urlcolor=$if(urlcolor)$$urlcolor$$else$blue$endif$,
            linkcolor=$if(linkcolor)$$linkcolor$$else$magenta$endif$,
            pdfborder={0 0 0}}
\urlstyle{same}  % don't use monospace font for urls
$if(links-as-notes)$
% Make links footnotes instead of hotlinks:
\renewcommand{\href}[2]{#2\footnote{\url{#1}}}
$endif$
$if(strikeout)$
\usepackage[normalem]{ulem}
% avoid problems with \sout in headers with hyperref:
\pdfstringdefDisableCommands{\renewcommand{\sout}{}}
$endif$
\setlength{\parindent}{0pt}
%\setlength{\parskip}{6pt plus 2pt minus 1pt}
\setlength{\emergencystretch}{3em}  % prevent overfull lines

\title{\huge 在OSX平台上的XeLaTeX中文測試} % 設置標題，使用巨大字體
\author{FoolEgg.com} 		% 設置作者
\date{February 2013} 		% 設置日期
\usepackage{titling}
\setlength{\droptitle}{-8em} 	% 將標題移動至頁面的上面

\usepackage{fancyhdr}
\usepackage{lastpage}
\pagestyle{fancyplain}

$if(numbersections)$
\setcounter{secnumdepth}{5}
$else$
\setcounter{secnumdepth}{0}
$endif$
$if(verbatim-in-note)$
\VerbatimFootnotes % allows verbatim text in footnotes
$endif$
$if(lang)$
\ifxetex
  \usepackage{polyglossia}
  \setmainlanguage{$mainlang$}
\else
  \usepackage[$lang$]{babel}
\fi
$endif$
$for(header-includes)$
$header-includes$
$endfor$

$if(title)$
\title{$title$}
$endif$
\author{$for(author)$$author$$sep$ \and $endfor$}
\date{$date$}

\begin{document}
$if(title)$
\maketitle
$endif$

$for(include-before)$
$include-before$

$endfor$
$if(toc)$
{
\hypersetup{linkcolor=black}
\setcounter{tocdepth}{$toc-depth$}
\tableofcontents
}
$endif$
$body$

$if(natbib)$
$if(biblio-files)$
$if(biblio-title)$
$if(book-class)$
\renewcommand\bibname{$biblio-title$}
$else$
\renewcommand\refname{$biblio-title$}
$endif$
$endif$
\bibliography{$biblio-files$}

$endif$
$endif$
$if(biblatex)$
\printbibliography$if(biblio-title)$[title=$biblio-title$]$endif$

$endif$
$for(include-after)$
$include-after$

$endfor$
\end{document}

#pandoc #template #chinses #pdf #markdown

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

MacTex BasicTeX

“MacTeX” 和 “BasicTeX” 是 TeX Live 發行版的兩個變體，用於 macOS 系統。它們都提供了一個完整的 TeX 環境，用於創建和處理 LaTeX 文檔。

1. MacTeX： MacTeX 是一個完整的 TeX Live 發行版，包含了大量的套件、字體、工具和文檔。它提供了一個完整的 LaTeX 環境，適用於需要大量功能和套件的用戶，例如學術研究和出版。

2. BasicTeX： BasicTeX 是 TeX Live 的一個輕量級版本，僅包含了核心的 TeX 和 LaTeX 套件。它適用於那些希望保持較小的安裝尺寸、僅使用基本功能的用戶，或者需要自定義安裝的用戶。BasicTeX 不包含大部分附加的套件和字體，但您可以通過 tlmgr 命令安裝所需的套件。

無論您選擇使用 MacTeX 還是 BasicTeX，都可以在 macOS 上創建和編譯 LaTeX 文檔。選擇哪個版本取決於您的需求和偏好。如果您需要一個完整的 LaTeX 環境，MacTeX 是一個不錯的選擇。如果您希望保持較小的安裝尺寸，或者只需要基本功能，BasicTeX 可能更合適。

您可以在 TeX Live 的官方網站上下載 MacTeX 和 BasicTeX，並根據您的需求進行安裝。

#LaTex

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

latex

LaTeX 是一種排版系統，用於創建高質量的科學和技術文件，如學術論文、報告、書籍、期刊文章等。它基於 TeX 排版系統，通過使用結構化的標記語言，使得用戶可以專注於文檔的內容，同時自動處理排版和格式。

以下是一些關於 LaTeX 的重要特點和用法：

1. 結構化排版： LaTeX 使用結構化的標記語言，如命令和環境，來描述文檔的結構和格式。這使得用戶可以輕鬆地定義章節、標題、段落、圖片、表格等元素。

2. 自動排版： LaTeX 處理排版細節，如頁面佈局、字體、段落間距、對齊等。這讓用戶無需手動調整，即可生成專業水準的文檔。

3. 數學支援： LaTeX 在科學和數學領域中廣泛使用，因為它提供了強大的數學排版能力。用戶可以輕鬆地創建數學公式、方程式和符號。

4. 論文和期刊： 許多學術期刊和出版物接受 LaTeX 格式的投稿，因為它可以生成專業和一致的排版。

5. 模板和主題： LaTeX 提供了各種模板和主題，用戶可以選擇不同風格的文檔佈局，並在其基礎上進行自定義。

6. 交叉引用和參考： LaTeX 允許用戶輕鬆地創建交叉引用、參考和引文，這有助於生成準確的引文清單和參考文獻。

7. 可擴展性： LaTeX 是一個開源系統，用戶可以編寫自己的宏包和類，以擴展其功能。

8. 跨平台： LaTeX 可以在不同的操作系統上運行，包括 Windows、macOS 和各種 Linux 發行版。

LaTeX 使用一種以 .tex 為擴展名的文件來描述文檔內容，然後通過編譯這個 .tex 文件來生成輸出，通常是 PDF 格式的文檔。編譯過程涉及多次運行 TeX 引擎，以生成最終的輸出文檔。

需要注意的是，LaTeX 的學習曲線可能較為陡峭，因為它要求用戶熟悉一些特定的命令和語法。但一旦掌握了基本的概念和常用的命令，LaTeX 可以成為一個強大且高效的文檔製作工具。

#LaTex

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

conda remove package

要使用 Conda 移除（刪除）一個已安裝的套件，您可以在終端或命令提示符中運行以下命令：

conda remove package_name

在這個命令中，package_name 是您要移除的套件的名稱。替換它為您實際要移除的套件的名稱。

例如，如果您要移除名為 “numpy” 的套件，您可以運行：

conda remove numpy

執行這個命令後，Conda 將提示您確認是否要移除指定的套件。輸入 y 或 yes 確認後，Conda 將移除該套件及其相關的文件和依賴。

請注意，移除套件時，請小心確保您確實不再需要該套件，因為移除後將無法復原。如果其他套件依賴於該套件，可能會產生問題，因此建議謹慎操作。

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

conda remove package

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

test

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

conda remove package

要使用 Conda 移除（刪除）一個已安裝的套件，您可以在終端或命令提示符中運行以下命令：

conda remove package_name

在這個命令中，package_name 是您要移除的套件的名稱。替換它為您實際要移除的套件的名稱。

例如，如果您要移除名為 “numpy” 的套件，您可以運行：

conda remove numpy

執行這個命令後，Conda 將提示您確認是否要移除指定的套件。輸入 y 或 yes 確認後，Conda 將移除該套件及其相關的文件和依賴。

請注意，移除套件時，請小心確保您確實不再需要該套件，因為移除後將無法復原。如果其他套件依賴於該套件，可能會產生問題，因此建議謹慎操作。

#conda #remove #package

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

pip uninstall package

要使用 pip 卸載（刪除）一個 Python 套件，您可以在終端或命令提示符中運行以下命令：

pip uninstall package_name

在這個命令中，package_name 是您要卸載的套件的名稱。替換它為您實際要卸載的套件的名稱。

例如，如果您要卸載名為 “requests” 的套件，您可以運行：

pip uninstall requests

執行這個命令後，pip 將提示您確認是否要卸載指定的套件。輸入 y 或 yes 確認後，pip 將刪除該套件及其相關的文件和依賴。

請注意，卸載套件時，請小心確保您確實不再需要該套件，因為卸載後將無法復原。如果其他套件依賴於該套件，可能會產生問題，因此建議謹慎操作。

#pip #uninstall

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

pandoc

Pandoc 是一個多格式文件轉換工具，可以將一種標記語言（如 Markdown、HTML、LaTeX 等）的文件轉換為另一種格式（如 PDF、HTML、Word 等）。它支持多種輸入和輸出格式，並且具有強大的自定義和配置能力。

以下是一些 Pandoc 的主要特點和用法：

1. 多格式轉換： Pandoc 支持許多不同的輸入和輸出格式，包括 Markdown、HTML、LaTeX、PDF、Docx、EPUB 等。這使您可以在不同格式之間輕鬆進行轉換。

2. 自定義模板： 您可以使用 Pandoc 的模板系統來定制輸出文檔的外觀和格式。這使您可以根據需求進行設計和排版。

3. 命令行工具： Pandoc 提供命令行界面，允許您使用命令行將文件從一個格式轉換為另一個格式。

4. 擴展語法： Pandoc 支持各種擴展語法和選項，這使您可以在輸入文件中使用更多的功能和元素，以及在輸出文件中進行更多的自定義。

5. 數學支持： Pandoc 支持數學表達式的轉換，可以將 LaTeX 數學表達式轉換為其他格式，如 HTML 或 Word。

6. 引用格式： Pandoc 支持不同引用格式，如 CSL（Citation Style Language）和 BibTeX，使您能夠在文檔中添加引用和參考。

以下是使用 Pandoc 進行基本 Markdown 到 PDF 轉換的命令示例：

pandoc input.md -o output.pdf

在這個示例中，input.md 是您的 Markdown 文件的名稱，output.pdf 是生成的 PDF 文件的名稱。您可以通過添加額外的選項和配置來自定義轉換過程。

總之，Pandoc 是一個功能強大的多格式文件轉換工具，適用於將各種標記語言的文件轉換為其他格式。它廣泛用於文檔編寫、自動化和數學表達式的處理等多個領域。

#pandoc #convert #html #markdown #pdf #LaTex #Word

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

bash

Bash（Bourne Again Shell）是一種Unix-like 系統中的命令行解釋器或 shell，用於解釋和執行用戶輸入的命令、腳本和指令。Bash 是許多 Linux 和 macOS 系統中的默認 shell，它提供了一個命令行界面，允許用戶與計算機進行交互。

以下是 Bash 的一些主要特點和功能：

1. 命令解釋和執行： Bash 允許用戶在命令行界面中輸入命令，然後解釋和執行這些命令。這些命令可以是系統命令、腳本文件或用戶自定義的指令。

2. 自動完成： Bash 支持命令自動完成，這意味著當您輸入部分命令或文件名時，Bash 可以根據已經存在的命令和文件進行自動建議，以節省時間和提高效率。

3. 歷史記錄： Bash 記錄用戶在命令行界面上輸入的命令，允許您在後續使用中輕鬆查找和重複使用之前的命令。

4. 環境變數和配置： Bash 允許您定義和管理環境變數，這些變數可以影響命令行界面的行為和外觀。

5. 管道和重定向： Bash 支持管道（|）和重定向（>、< 等）操作，這些操作允許您將一個命令的輸出作為另一個命令的輸入，或將輸出重定向到文件中。

6. 腳本編程： Bash 也可以用於編寫腳本文件，這些文件包含一系列的命令，可以被一次性地執行。這對於自動化任務和批處理非常有用。

7. 條件和迴圈： Bash 支持條件語句（if、else、elif）和迴圈（for、while），允許您在腳本中實現更複雜的邏輯。

總之，Bash 是一個強大的命令行解釋器，用於在 Unix-like 系統中與計算機進行交互、執行命令和編寫腳本。它是一個廣泛使用的工具，尤其在系統管理、開發和運維方面。

#bash #shell

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

ssh

SSH（Secure Shell）是一種加密的網絡協議，用於在不安全的網絡中安全地遠程連接到遠端計算機或服務器。SSH 提供了一個安全的通信通道，使您可以進行加密的遠程訪問、數據傳輸和遠程操作。

SSH 主要用於以下方面：

1. 遠程登錄（Remote Login）： 使用 SSH，您可以從一台計算機遠程登錄到另一台計算機。這對於管理遠程伺服器、虛擬機器等非常有用。

2. 文件傳輸（Secure File Transfer）： SSH 還支持安全的文件傳輸，您可以使用 scp（Secure Copy）或 sftp（Secure FTP）命令進行加密的文件傳輸。

3. 遠程執行命令（Remote Command Execution）： 您可以使用 SSH 遠程執行命令，從而在遠程計算機上運行命令並查看結果。

SSH 通信是安全的，因為它使用加密技術來保護通信內容。當您使用 SSH 連接到遠端計算機時，通信過程中的數據是加密的，這樣即使有人竊聽通信，也無法獲取有用的信息。

通常，SSH 使用用戶名和密碼進行身份驗證。另一種更安全的身份驗證方式是使用 SSH 金鑰對。SSH 金鑰對包括一個公鑰和一個私鑰，私鑰保存在用戶的本地計算機上，而公鑰則儲存在遠程服務器上。通過比較公鑰和私鑰，遠程服務器可以驗證用戶的身份。

總之，SSH 是一種安全的協議，允許您在不安全的網絡中進行加密的遠程連接、文件傳輸和遠程操作。這在系統管理、開發和運維等領域非常有用。

#ssh #remoteLogin

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

shebang

Shebang（也稱為 hashbang、pound-bang 或 hash-exclam）是在 Unix-like 系統中用於指定腳本解釋器的特殊語法。它位於腳本文件的第一行，後面跟著一個路徑，指示系統使用該路徑指定的解釋器來執行腳本。Shebang 通常用於指定腳本文件的程式語言環境，以及如何運行腳本。

Shebang 的格式如下：

#!/path/to/interpreter

在這個語法中，#!/ 是 Shebang 的開始，然後後面是解釋器的路徑。例如，如果您有一個用於 Python 的腳本，您可以在文件的第一行添加以下 Shebang：

#!/usr/bin/python

這告訴系統使用 /usr/bin/python 來執行該腳本。

以下是一些常見的 Shebang 用法：

• #!/bin/bash：使用 Bash 作為腳本的解釋器。
• #!/usr/bin/python：使用 Python 2.x 作為腳本的解釋器。
• #!/usr/bin/python3：使用 Python 3.x 作為腳本的解釋器。
• #!/usr/bin/env python：使用環境變數中指定的 Python 解釋器，這可以避免使用固定的路徑，但需要確保您的環境變數正確設置。

Shebang 對於直接從命令行執行腳本非常有用，讓系統知道如何運行腳本。請注意，Shebang 的格式和解釋器的路徑可能因系統而異，所以您需要確保指定正確的解釋器路徑。

#shebang #bash #ssh

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

conda create environment python=xxx

在使用 Conda 創建一個名為 “python3.9” 的 Python 3.9 環境時，您可以遵循以下步驟：

1. 打開終端或命令提示符。

2. 在終端中，輸入以下命令並運行，這將創建一個名為 “python3.9” 的 Python 3.9 環境：

   conda create --name python3.9 python=3.9
   

   此命令指定了環境名稱（”python3.9”），並通過 python=3.9 參數指定要使用的 Python 版本為 3.9。

3. 當提示您是否要繼續時，輸入 y 或 yes 以確認創建環境。

4. Conda 將開始創建環境，安裝所需的包和依賴項。這可能需要一些時間。

5. 完成後，您可以使用以下命令啟動和進入這個新創建的環境：

   • 在 Windows 上：

     conda activate python3.9
     

   • 在 macOS 和 Linux 上：

     source activate python3.9
     

   或者，您也可以使用以下命令來進入環境：

   conda activate python3.9
   

現在您已經成功創建了一個名為 “python3.9” 的 Python 3.9 環境。在此環境中，您可以安裝和運行 Python 3.9 的相關套件和應用程序。如果您需要切換回其他環境或退出環境，請使用 conda deactivate 命令。

請注意，上述步驟假設您已經在系統中安裝了 Conda。如果您尚未安裝 Conda，請首先安裝 Conda，然後再執行上述步驟。

#conda #python #env #create #version

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

conda delete env

要在 Conda 中刪除一個環境，您可以使用以下步驟：

1. 打開終端或命令提示符： 首先，您需要打開終端（在 macOS 和 Linux 上）或命令提示符（在 Windows 上）。

2. 刪除環境： 輸入以下命令以刪除指定的環境。請將 environment_name 替換為您要刪除的環境的名稱。

   conda env remove --name environment_name
   

   例如，如果要刪除名為 “myenv” 的環境，則命令將是：

   conda env remove --name myenv
   

3. 確認刪除： 在執行上述命令後，Conda 將提示您確認是否要刪除環境。輸入 y 或 yes 以確認刪除。

4. 等待刪除完成： Conda 將開始刪除環境及其相關套件和依賴項。這可能需要一些時間，具體取決於環境的大小。

一旦刪除完成，您的指定環境將被徹底刪除，並且相關的資源將被釋放。

請小心確認要刪除的環境，因為刪除後將無法恢復。在執行刪除命令之前，建議您確保您不再需要該環境以及其中的任何數據。

#conda #delete #env #python

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

how to get splitter text one by one

notes

To split text input into individual words one by one using Apple Shortcuts, you can use a combination of actions. Here’s how you can achieve this:

1. Open Shortcuts App: Open the Shortcuts app on your iOS device.

2. Create a New Shortcut:
   • Tap the “+” button in the top right corner to create a new shortcut.
3. Add Action:
   • Tap “Add Action” to add actions to your shortcut.
4. Search and Add “Text”:
   • Search for and select the “Text” action.
   • In the Text action, set the action to “Ask for Input” and customize the prompt as needed.
5. Add “Split Text” Action:
   • Tap “Add Action” again to add another action.
   • Search for and select the “Split Text” action.
   • In the Split Text action, choose “Space” as the delimiter.
6. Add “Repeat with Each” Action:
   • Tap “Add Action” again to add another action.
   • Search for and select the “Repeat with Each” action.
   • Set the “Repeat with Each” action to use the output of the “Split Text” action.
7. Add Actions Inside the Loop:
   • Within the “Repeat with Each” loop, you can add actions that will be performed for each word in the split text.
8. Add “Get Item from List” Action:
   • Inside the loop, search for and select the “Get Item from List” action.
   • Set the “List” field to the output of the “Split Text” action.
   • Set the “Index” to “Repeat Index.”
9. Perform Actions with Each Word:
   • Add actions within the loop that use the current word obtained from the “Get Item from List” action.
   • For example, you can create notes, add tags, or perform other tasks with each word.
10. Done and Save:
    • Tap “Done” to finish configuring your shortcut.
    • Give your shortcut a meaningful name and tap “Done” again to save it.
11. Run Shortcut:
    • You can now run your shortcut by tapping on it in the Shortcuts app or using Siri voice commands.

With this setup, the shortcut will take your input text, split it into individual words, and then perform actions for each word in the split text. This can be useful for tasks where you want to process or manipulate each word separately. Make sure to customize the actions within the loop according to your needs.

#shortcuts #split #repeatwitheach

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

notes的寫法

包括note的格式，標題

⁃	標題記得加# 這樣md才能識別
⁃	正文開頭要寫一段summary，這樣方便複習。主要是總結這個note的大概，就像chatgpt一樣

#note #bear #tutorial #workflow

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

車道檢測 opencv

這是一個使用OpenCV讀取視頻並進行車道檢測的示例代碼。該示例將讀取視頻文件，將每一幀影像進行車道檢測，然後將檢測結果顯示在新的影像中。請確保已經安裝了OpenCV庫。

import cv2
import numpy as np

def region_of_interest(img, vertices):
    mask = np.zeros_like(img)
    cv2.fillPoly(mask, [vertices], 255)
    masked_img = cv2.bitwise_and(img, mask)
    return masked_img

def draw_lines(img, lines, color=(0, 255, 0), thickness=3):
    for line in lines:
        for x1, y1, x2, y2 in line:
            cv2.line(img, (x1, y1), (x2, y2), color, thickness)

def detect_lanes(image):
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    edges = cv2.Canny(gray, 100, 200)

    height, width = edges.shape
    roi_vertices = [(0, height), (width / 2, height / 2), (width, height)]
    masked_edges = region_of_interest(edges, np.array([roi_vertices], np.int32))

    lines = cv2.HoughLinesP(masked_edges, 1, np.pi / 180, threshold=50, minLineLength=100, maxLineGap=50)

    line_image = np.zeros_like(image)
    draw_lines(line_image, lines)

    combo_image = cv2.addWeighted(image, 0.8, line_image, 1, 1)

    return combo_image

# 讀取視頻文件
video_path = 'path_to_your_video.mp4'
cap = cv2.VideoCapture(video_path)

while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break

    # 進行車道檢測
    result_frame = detect_lanes(frame)

    # 顯示結果
    cv2.imshow('Lane Detection', result_frame)

    # 按下 'q' 鍵退出迴圈
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

請確保將video_path更改為您自己的視頻文件路徑。這個示例代碼將連續地從視頻中讀取幀，將每一幀影像進行車道檢測，然後在新窗口中顯示處理後的影像。您可以按下 ‘q’ 鍵來退出視頻播放。

這只是一個簡單的視頻處理示例，實際應用可能需要更多的調整和優化，以實現更好的車道檢測效果。

X

#lanedetection #lanechanging #opencv #video_reading #hough #draw_line_video #opencv_color #combo_image

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

markdown基本用法

markdown的基本用法

Markdown的基本用法是這樣的 medium教程

Subheading

##中 subheading
###小 maybe used as topic heading
####小小 sub-topic heading

Website / Share

You can read my blog here.

Images

! redTVrabbit

這裡的！與後面的[]有個空格，注意一下，後面的[]與括號（）沒有空格。

List

1. ordered

• first item Some text about it
• second item some text about it

  2. un-ordered

  1. Bb
  2. Kk
  3. G

Block quotes

> say something.

say something.

Code

code - one line

Use this code

code -multiple line

Use this

multiple
line of code 
hah

add language name

# ping on google server (python)
ping -t www.google.com

Bold

**bold** or __bold__

bold bold

Italic (傾斜)

*italice*
_italice_

italice italice

X

#medium #markdown #tutorial #code

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Markdown編輯器

以下是一些常用的基於網頁的 Markdown 編輯器，你可以在瀏覽器中使用這些工具來進行 Markdown 編輯和寫作：

1. Dillinger： Dillinger 是一個線上 Markdown 編輯器，提供所見即所得（WYSIWYG）預覽和即時導出功能。它支援雲端儲存和同步。

2. StackEdit： StackEdit 是一個全功能的線上 Markdown 編輯器，可以與 Google 雲端儲存、Dropbox 等集成，同時支援離線編輯。

3. Typora Online： Typora 提供了線上版本，它保留了 Typora 的所見即所得編輯風格，使你可以在瀏覽器中進行類似桌面版的編輯。

4. Markable： Markable 是一個簡單易用的線上 Markdown 編輯器，支援實時預覽，同時可以將文件導出為 PDF。

5. CodiMD： CodiMD 是一個開源的協作 Markdown 編輯器，可以在網頁上進行寫作和協作，支援即時預覽和版本控制。

6. Zettlr Web: Zettlr 是一個面向學術寫作的 Markdown 編輯器，它提供了線上版本，支援 Markdown、Latex、Citations 等功能。

7. Editor.md： Editor.md 是一個功能豐富的 Markdown 編輯器，支援所見即所得預覽、圖片拖放、代碼高亮等功能。

8. SimpleMDE： SimpleMDE 是一個輕量級的 Markdown 編輯器，提供簡潔的編輯界面和基本的功能。

請注意，這些線上 Markdown 編輯器可能會有不同的功能和界面風格，你可以根據個人需求選擇最適合你的工具。

X

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Opencv 包的組成

OpenCV（開放原始碼電腦視覺庫）提供了許多不同的模組和包，用於各種圖像處理、計算機視覺和機器學習任務。以下是OpenCV主要的一些模組和包：

1. core： 提供了基本的數據結構、數學運算和矩陣操作，是OpenCV的核心模組。

2. imgproc： 提供了圖像處理相關的功能，包括濾波、幾何變換、邊緣檢測、直方圖等。

3. video： 用於處理視頻數據，包括讀取和寫入視頻、視頻流處理、運動估計等。

4. videoio： 提供了視頻輸入和輸出的功能，支持多種格式和視頻捕獲設備。

5. highgui： 提供了圖形用戶界面（GUI）相關的函數，用於顯示圖像和視頻，以及創建滑塊、按鈕等控件。

6. features2d： 用於特徵檢測和匹配，包括關鍵點檢測、描述子匹配等功能。

7. objdetect： 提供了對象檢測和識別的功能，包括人臉識別、物體檢測等。

8. calib3d： 用於相機校準、立體視覺和三維重建等。

9. ml： 提供了機器學習相關的函數，包括統計模型、機器學習算法等。

10. dnn： 用於深度學習，可以將預訓練的深度學習模型集成到OpenCV中。

11. photo： 提供了影像增強和處理相關的功能，包括曝光校正、白平衡等。

12. stitching： 用於圖像拼接和全景圖像生成。

13. gapi： 用於設計和構建可編程的計算圖形，用於高效的圖像處理。

14. flann： 快速最近鄰搜索庫，用於快速搜尋最近的鄰居點。

15. contrib： 社區貢獻的模組，包括一些額外的功能和實驗性的特性。

以上只是OpenCV中一些主要的模組和包。每個模組都提供了一系列函數和工具，用於不同的圖像處理和計算機視覺任務。您可以根據您的需求選擇適合的模組和函數進行開發和應用。

cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) 是 OpenCV 中用來將彩色圖像轉換為灰階圖像的功能。在某些情況下，我們可能需要將彩色圖像轉換為灰階圖像，這種轉換通常有以下幾個原因：

1. 降低計算量： 彩色圖像由紅色、綠色和藍色三個通道組成，每個通道都有自己的數值，這增加了處理圖像所需的計算量。轉換為灰階圖像可以減少通道的數量，從而減少處理圖像所需的計算資源。

2. 簡化分析： 在某些應用中，我們可能只對圖像中的亮度信息感興趣，而不關心顏色信息。轉換為灰階圖像可以將圖像的信息簡化為單一的亮度值，使分析變得更容易。

3. 節省存儲空間： 灰階圖像只有一個通道，而彩色圖像有三個通道。轉換為灰階可以節省存儲空間，尤其是在處理大量圖像時。

4. 特徵提取： 在一些圖像處理任務中，如物體檢測、人臉識別等，灰階圖像中的某些特徵可能比彩色圖像更容易檢測和提取。

總的來說，將圖像轉換為灰階可以根據應用的需要簡化圖像，減少計算成本，並更容易進行分析和處理。但請注意，這種轉換可能會丟失一些顏色信息，因此在某些情況下，你可能需要保留彩色信息進行分析。

在圖像處理中，RGB 和灰階是兩種不同的表示方式，用於描述圖像中像素的顏色和亮度信息。

RGB（紅綠藍）表示： RGB 是一種彩色表示方式，它使用紅色（R）、綠色（G）和藍色（B）三個顏色通道來描述圖像中的顏色。每個通道的值範圍通常是 0 到 255，其中 0 表示該顏色通道的最小強度，而 255 表示最大強度。通過在這三個通道中調整不同強度的值，我們可以混合出各種顏色。例如，紅色的像素在紅色通道中的值接近 255，而在綠色和藍色通道中的值接近 0。

灰階表示： 灰階是一種單通道表示方式，它只使用一個通道來描述圖像中的亮度（灰度）信息，而不考慮顏色。每個像素的灰度值通常介於 0 到 255 之間，其中 0 表示黑色，255 表示白色，中間的值表示不同的灰度級別。灰階圖像可以看作是將彩色圖像的紅綠藍三個通道的值進行加權平均，以得到單一的灰度值。

在進行某些圖像處理任務時，我們可能只關心圖像的亮度信息，而不需要顏色信息。這時，我們可以將圖像轉換為灰階表示，從而簡化圖像並減少計算成本。cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) 就是 OpenCV 中的一個函數，用於將彩色圖像轉換為灰階圖像。這對於許多圖像處理任務（如邊緣檢測、特徵提取等）是很有用的。

#opencv_color

當卷積核滑過圖像時，它計算每個像素周圍的亮度變化是通過將卷積核內的像素值和對應位置的圖像像素值進行相乘，然後將乘積相加起來。

讓我們以 Sobel X 運算子為例，這個卷積核是：

-1  0  1
-2  0  2
-1  0  1

現在假設我們將這個卷積核的中心放在圖像上的一個像素點上，並計算周圍的像素值和卷積核中的值的乘積總和。這個總和就是計算得到的梯度值。

例如，假設我們將卷積核的中心放在圖像上的一個位置，該位置周圍的像素值如下：

a  b  c
d  e  f
g  h  i

我們將卷積核和像素值進行對應位置的相乘，然後將乘積相加，即：

梯度值 = (-1 * a) + (0 * b) + (1 * c) + (-2 * d) + (0 * e) + (2 * f) + (-1 * g) + (0 * h) + (1 * i)

這個梯度值表示了該位置的像素周圍的亮度變化情況，特別是水平方向上的變化。通過將卷積核在圖像上滑動，我們可以計算出整個圖像在水平方向上的梯度變化，並得到一個新的圖像，稱為水平方向梯度圖像。同樣地，我們可以使用垂直方向的 Sobel 運算子來計算垂直方向的梯度，得到垂直方向梯度圖像。這些梯度圖像對於找出圖像中的邊緣和特徵非常有用。

X #…

#opencv #lanedetection

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

bear和notes的工作屆流程

用bear和notes的workflow

1. 先用chatgpt複製我需要的文字和代碼，最重要是要把我的問題copy下來。
2. 這裡選擇—— copy — as markdown。
3. 再在右下角放入筆記本-具體的文件夾，每一個知識板塊只可以有一個文檔
4. 加好了之後可以在bear裡打開這個note，複習的時候可以用。 ！bear我沒有買會員，所以東西都必須經過notes，否則會搞丟。

X

#workflow #bear #markdown

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Opencv顏色的轉換

cv2.cvtColor() 是OpenCV中的一個函數，用於執行影像的顏色空間轉換。顏色空間轉換是一種將影像從一種顏色表示轉換為另一種顏色表示的操作。在計算機視覺和影像處理中，常常需要在不同的顏色空間之間進行轉換，以便進行特定的操作，如顏色修正、特徵檢測、目標追蹤等。

#opencv #opencv_color

函數的語法如下：

dst = cv2.cvtColor(src, code[, dst[, dstCn]])

•	src：要轉換的原始影像。
•	code：轉換顏色空間的代碼，如 cv2.COLOR_BGR2GRAY（從BGR到灰度）、cv2.COLOR_BGR2HSV（從BGR到HSV）等。您可以使用不同的代碼來執行不同的轉換。
•	dst（可選）：輸出的轉換後的影像，與原始影像相同的大小和深度。
•	dstCn（可選）：輸出影像的通道數，如果未指定，則保持與原始影像相同的通道數。

以下是一個示例，將彩色影像轉換為灰度影像：

import cv2

讀取彩色影像

image = cv2.imread(‘image.jpg’)

將影像從BGR轉換為灰度

gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

顯示轉換後的影像

cv2.imshow(‘Gray Image’, gray_image) cv2.waitKey(0) cv2.destroyAllWindows()

這個示例使用了 cv2.COLOR_BGR2GRAY 代碼來將BGR彩色影像轉換為灰度影像。您可以通過更改 code 參數，使用不同的代碼進行不同的顏色空間轉換。

這是一個使用OpenCV讀取視頻並進行車道檢測的示例代碼。該示例將讀取視頻文件，將每一幀影像進行車道檢測，然後將檢測結果顯示在新的影像中。請確保已經安裝了OpenCV庫。

import cv2 import numpy as np

def region_of_interest(img, vertices): mask = np.zeros_like(img) cv2.fillPoly(mask, [vertices], 255) masked_img = cv2.bitwise_and(img, mask) return masked_img

def draw_lines(img, lines, color=(0, 255, 0), thickness=3): for line in lines: for x1, y1, x2, y2 in line: cv2.line(img, (x1, y1), (x2, y2), color, thickness)

def detect_lanes(image): gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) edges = cv2.Canny(gray, 100, 200)

height, width = edges.shape
roi_vertices = [(0, height), (width / 2, height / 2), (width, height)]
masked_edges = region_of_interest(edges, np.array([roi_vertices], np.int32))

lines = cv2.HoughLinesP(masked_edges, 1, np.pi / 180, threshold=50, minLineLength=100, maxLineGap=50)

line_image = np.zeros_like(image)
draw_lines(line_image, lines)

combo_image = cv2.addWeighted(image, 0.8, line_image, 1, 1)

return combo_image

讀取視頻文件

video_path = ‘path_to_your_video.mp4’ cap = cv2.VideoCapture(video_path)

while cap.isOpened(): ret, frame = cap.read() if not ret: break

# 進行車道檢測
result_frame = detect_lanes(frame)

# 顯示結果
cv2.imshow('Lane Detection', result_frame)

# 按下 'q' 鍵退出迴圈
if cv2.waitKey(1) & 0xFF == ord('q'):
    break

cap.release() cv2.destroyAllWindows()

請確保將video_path更改為您自己的視頻文件路徑。這個示例代碼將連續地從視頻中讀取幀，將每一幀影像進行車道檢測，然後在新窗口中顯示處理後的影像。您可以按下 ‘q’ 鍵來退出視頻播放。

這只是一個簡單的視頻處理示例，實際應用可能需要更多的調整和優化，以實現更好的車道檢測效果。

檢測車道是自駕車和車輛安全系統中的一個重要任務，它能夠幫助車輛保持在正確的車道內行駛，並避免偏離車道造成的事故。以下是一些常見的車道檢測方法：

2.	攝像頭或攝像頭陣列： 車輛通常配備多個攝像頭，以捕捉車輛周圍的影像。這些攝像頭可以用於檢測車道線、道路邊界和其他車輛，進而幫助車輛確定自身位置。

2.	計算機視覺技術： 利用計算機視覺技術，如圖像處理和模式識別，可以檢測和跟踪道路標記，例如車道線和中心線。這些技術可以分析攝像頭捕捉到的影像，識別出車道的位置和方向。

2.	激光雷達（LiDAR）： LiDAR系統使用激光脈衝來感知周圍環境。它可以創建一個高精度的3D地圖，從而能夠檢測道路上的障礙物和車道線等信息。

2.	超聲波感測器： 超聲波感測器可以用於短距離的車道偵測，幫助車輛感知周圍的物體和障礙物，從而確定車道的位置。

2.	GPS和地圖數據： 全球定位系統（GPS）可以提供車輛的位置信息，並與數字地圖數據相結合，幫助車輛識別道路的位置和形狀。

2.	車輛動態信息： 車輛的動態信息，如方向盤的轉動角度、加速度和車速，也可以用於推斷車輛是否偏離車道。

2.	機器學習和深度學習： 使用機器學習和深度學習技術，可以訓練模型來辨識和預測車道線、道路邊界和其他交通標誌。這需要大量的標記數據和適當的算法。

綜合使用上述方法，車輛可以實現準確的車道檢測，並保持在正確的行駛車道內。不同的自動駕駛系統可能會使用不同的技術組合，以確保車輛在各種道路條件下都能實現安全和可靠的車道保持功能。

#lanedetection

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

車道檢測的code

cv2.cvtColor() 是OpenCV中的一個函數，用於執行影像的顏色空間轉換。顏色空間轉換是一種將影像從一種顏色表示轉換為另一種顏色表示的操作。在計算機視覺和影像處理中，常常需要在不同的顏色空間之間進行轉換，以便進行特定的操作，如顏色修正、特徵檢測、目標追蹤等。

函數的語法如下：

dst = cv2.cvtColor(src, code[, dst[, dstCn]])

•	src：要轉換的原始影像。
•	code：轉換顏色空間的代碼，如 cv2.COLOR_BGR2GRAY（從BGR到灰度）、cv2.COLOR_BGR2HSV（從BGR到HSV）等。您可以使用不同的代碼來執行不同的轉換。
•	dst（可選）：輸出的轉換後的影像，與原始影像相同的大小和深度。
•	dstCn（可選）：輸出影像的通道數，如果未指定，則保持與原始影像相同的通道數。

以下是一個示例，將彩色影像轉換為灰度影像：

import cv2

讀取彩色影像

image = cv2.imread(‘image.jpg’)

將影像從BGR轉換為灰度

gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

顯示轉換後的影像

cv2.imshow(‘Gray Image’, gray_image) cv2.waitKey(0) cv2.destroyAllWindows()

這個示例使用了 cv2.COLOR_BGR2GRAY 代碼來將BGR彩色影像轉換為灰度影像。您可以通過更改 code 參數，使用不同的代碼進行不同的顏色空間轉換。

這是一個使用OpenCV讀取視頻並進行車道檢測的示例代碼。該示例將讀取視頻文件，將每一幀影像進行車道檢測，然後將檢測結果顯示在新的影像中。請確保已經安裝了OpenCV庫。

import cv2 import numpy as np

def region_of_interest(img, vertices): mask = np.zeros_like(img) cv2.fillPoly(mask, [vertices], 255) masked_img = cv2.bitwise_and(img, mask) return masked_img

def draw_lines(img, lines, color=(0, 255, 0), thickness=3): for line in lines: for x1, y1, x2, y2 in line: cv2.line(img, (x1, y1), (x2, y2), color, thickness)

def detect_lanes(image): gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) edges = cv2.Canny(gray, 100, 200)

height, width = edges.shape
roi_vertices = [(0, height), (width / 2, height / 2), (width, height)]
masked_edges = region_of_interest(edges, np.array([roi_vertices], np.int32))

lines = cv2.HoughLinesP(masked_edges, 1, np.pi / 180, threshold=50, minLineLength=100, maxLineGap=50)

line_image = np.zeros_like(image)
draw_lines(line_image, lines)

combo_image = cv2.addWeighted(image, 0.8, line_image, 1, 1)

return combo_image

讀取視頻文件

video_path = ‘path_to_your_video.mp4’ cap = cv2.VideoCapture(video_path)

while cap.isOpened(): ret, frame = cap.read() if not ret: break

# 進行車道檢測
result_frame = detect_lanes(frame)

# 顯示結果
cv2.imshow('Lane Detection', result_frame)

# 按下 'q' 鍵退出迴圈
if cv2.waitKey(1) & 0xFF == ord('q'):
    break

cap.release() cv2.destroyAllWindows()

請確保將video_path更改為您自己的視頻文件路徑。這個示例代碼將連續地從視頻中讀取幀，將每一幀影像進行車道檢測，然後在新窗口中顯示處理後的影像。您可以按下 ‘q’ 鍵來退出視頻播放。

這只是一個簡單的視頻處理示例，實際應用可能需要更多的調整和優化，以實現更好的車道檢測效果。

檢測車道是自駕車和車輛安全系統中的一個重要任務，它能夠幫助車輛保持在正確的車道內行駛，並避免偏離車道造成的事故。以下是一些常見的車道檢測方法：

1.	攝像頭或攝像頭陣列： 車輛通常配備多個攝像頭，以捕捉車輛周圍的影像。這些攝像頭可以用於檢測車道線、道路邊界和其他車輛，進而幫助車輛確定自身位置。

2.	計算機視覺技術： 利用計算機視覺技術，如圖像處理和模式識別，可以檢測和跟踪道路標記，例如車道線和中心線。這些技術可以分析攝像頭捕捉到的影像，識別出車道的位置和方向。

3.	激光雷達（LiDAR）： LiDAR系統使用激光脈衝來感知周圍環境。它可以創建一個高精度的3D地圖，從而能夠檢測道路上的障礙物和車道線等信息。

4.	超聲波感測器： 超聲波感測器可以用於短距離的車道偵測，幫助車輛感知周圍的物體和障礙物，從而確定車道的位置。

5.	GPS和地圖數據： 全球定位系統（GPS）可以提供車輛的位置信息，並與數字地圖數據相結合，幫助車輛識別道路的位置和形狀。

6.	車輛動態信息： 車輛的動態信息，如方向盤的轉動角度、加速度和車速，也可以用於推斷車輛是否偏離車道。

7.	機器學習和深度學習： 使用機器學習和深度學習技術，可以訓練模型來辨識和預測車道線、道路邊界和其他交通標誌。這需要大量的標記數據和適當的算法。

綜合使用上述方法，車輛可以實現準確的車道檢測，並保持在正確的行駛車道內。不同的自動駕駛系統可能會使用不同的技術組合，以確保車輛在各種道路條件下都能實現安全和可靠的車道保持功能。

#lanedetection #code

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Gps數據exif的tag處理

由于标签标识符通常以十六进制表示，因此使用 0x 前缀来表示一个十六进制值。在这里，0x8825 表示 GPS 信息在 Exif 数据中的标签标识符。 在这个上下文中，0x8825 是一个十六进制数，代表了 GPS 信息在 Exif 数据中的标签标识符。在十进制中，0x8825 等于 34853。

GPSTAGS.get(tag, tag) 方法的作用是尝试从 GPSTAGS 字典中获取与给定的 tag 对应的标签名称。如果 tag 在字典中存在，那么返回对应的标签名称；如果不存在，返回 tag 本身（即使用原始的标签标识符）。 例如，假设 GPSTAGS 字典类似于以下内容： python

Copy code GPSTAGS = { 1: “GPS Version”, 2: “GPS Latitude”, 3: “GPS Longitude”, # … 其他键值对 … } 如果你调用 GPSTAGS.get(2, 2)，因为键 2 存在于字典中，将返回 “GPS Latitude”。但如果你调用 GPSTAGS.get(4, 4)，因为键 4 不存在于字典中，将返回 4。 这样的处理允许你将 Exif 数据中的标签标识符转换为易于理解的标签名称，从而更好地展示和解释 GPS 信息。

1 / 1

这个转换的公式涉及将度、分、秒表示的经纬度数据转换为十进制度数的形式。以下是公式的解释： • 度分秒转十进制度数： • 度（degrees）：这是度分秒表示法中的度部分。 • 分（minutes）：这是度分秒表示法中的分部分。 • 秒（seconds）：这是度分秒表示法中的秒部分。 • 要将度分秒表示法转换为十进制度数，首先将分除以 60（因为每度有 60 分），然后将秒除以 3600（因为每度有 3600 秒），最后将这三者相加，得到十进制度数。 • 方向： • ‘N’：北半球，纬度是正值。 • ‘S’：南半球，纬度是负值。 • ‘E’：东半球，经度是正值。 • ‘W’：西半球，经度是负值。 • 如果是南半球或西半球，则将计算得到的十进制度数变为负值。 总结来说，将度分秒转换为十进制度数的过程是将度数、分数和秒数的组合转换为一个等效的十进制小数，考虑方向来确定正负。这样的转换使得经纬度表示更加简洁和便于计算，并在地理信息系统（GIS）和其他应用中广泛使用。

#gps #exif

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Opencv主要結構和組成部分

OpenCV（開放原始碼電腦視覺庫）是一個廣泛使用的電腦視覺和圖像處理庫，用於開發各種視覺應用程序。它提供了許多功能和工具，用於處理圖像和視頻，包括載入、處理、分析和顯示影像。以下是OpenCV包的主要結構和組成部分：

1. Core 模組： 這是OpenCV的核心模組，提供了基本的數據結構、數學運算和矩陣操作。它包括了處理影像、向量和矩陣的函數，這些函數可用於圖像處理和計算機視覺。

2. Imgproc 模組： 這個模組提供了各種圖像處理函數，包括濾波、幾何變換、二值化、邊緣檢測等。它也包括了計算圖像直方圖、找到輪廓、計算圖像的梯度等功能。

3. Video 模組： 這個模組用於處理視頻數據，提供了處理視頻流、幀之間的操作、動態目標追蹤等功能。它還包括了對視頻中的運動估計和光流估計等處理方法的實現。

4. Highgui 模組： 這個模組提供了用於創建圖形用戶界面（GUI）的函數，可以用於顯示圖像和視頻、創建滑塊、按鈕等控件。

5. Features2d 模組： 這個模組包括了特徵檢測和匹配的函數，用於在圖像中檢測關鍵點並進行特徵匹配。

6. Objdetect 模組： 這個模組提供了對象檢測和識別的函數，包括人臉識別、物體檢測等功能。

7. Machine Learning 模組： 這個模組提供了機器學習相關的函數，包括統計模型、機器學習算法等。

8. Calib3d 模組： 這個模組用於相機校準、立體視覺和三維重建等。

9. Dnn 模組： 這個模組提供了深度學習相關的函數，可以將預訓練的深度學習模型集成到OpenCV中。

10. Contrib 模組： 這是一個社區貢獻的模組，包含了一些額外的功能和實驗性的特性。

這只是OpenCV包中一些主要模組的簡要介紹。OpenCV提供了豐富的函數和工具，用於處理各種視覺任務，從基本的圖像處理到複雜的計算機視覺應用。您可以根據您的需求選擇相應的模組和函數來完成您的項目。

#opencv

🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️下一個筆記🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️🐿️

Markdown 用法

#markdown #匯總今日內容