David Silver Lecture 4: Model-Free Prediction

1 Introduction

任务：第三章使用动态规划方法，解决known的MDP问题，这章通过model free prediction对一个unknown的MDP估计他的value function。下一章通过Model free control的方法针对一个unknown的MDP optimise value function。

2 Monte Carlo Learning

2.1 MC 方法的特点

  • learn directly from episodes of experiences
  • model free: no knowledge of MDP transitions / rewards
  • learn from complete episodes: no bootstrapping
  • simplest idea: value = mean return
  • Caveat: can only apply MC to episodic MDPs
    • all episodes must terminate

2.2 MC policy evaluation

在这里插入图片描述

##伪代码
1初始化：

  • 设定状态集合 S 和动作集合 A
  • 定义策略 π
  • 设定折扣因子 γ
  • 初始化每个状态 s 的价值函数 V(s) 为 0
  • 初始化每个状态 s 的回报列表 returns(s) 为空列表

2对于每个情节（episode）：

  • 初始化状态 s 为初始状态
  • 初始化轨迹 trajectory 为空列表
  • 当 s 不是终止状态时：
    • 按照策略 π 选择动作 a
    • 执行动作 a，得到下一个状态 s’ 和奖励 r
    • 将 (s, r) 添加到轨迹 trajectory
    • 更新状态 s 为 s’
  • 初始化累积回报 G 为 0
  • 从轨迹的末尾开始向前遍历每个时刻 (s, r)：
    • 更新累积回报 G = r + γ * G
    • 将 G 添加到 returns(s) 列表
    • 更新价值函数 V(s) 为 returns(s) 列表的平均值

3 输出价值函数 V

考虑一个简化的冰冻湖环境，其中有四个状态（S, F, H, G），分别表示起点、冰面、洞口和终点。在每个时间步，智能体可以选择左或右2个动作。我们要评估一个简单的策略：始终向右移动

import numpy as np
import random

# 环境参数
states = ["S", "F", "H", "G"]
n_states = len(states)
actions = ["left", "right"]
n_actions = len(actions)

# 策略
policy = np.zeros((n_states, n_actions))
policy[:, actions.index("right")] = 1

# 模拟函数
def step(state, action):
    if state == 0 and action == "right":
        return 1, 0
    if state == 1 and action == "right":
        return 2, 0
    if state == 1 and action == "left":
        return 0, 0
    if state == 2 and action == "right":
        return 3, 1
    if state == 2 and action == "left":
        return 1, 0
    return state, 0

# 参数
num_episodes = 5000
gamma = 0.99

# 初始化
returns = {state: [] for state in range(n_states)}
v = np.zeros(n_states)

# Monte Carlo Policy Evaluation
for episode in range(num_episodes):
    state = 0
    episode_trajectory = []

    while state != n_states - 1:
        action = np.random.choice(actions, p=policy[state, :])
        next_state, reward = step(state, action)
        episode_trajectory.append((state, reward))
        state = next_state

    g = 0
    for t in range(len(episode_trajectory) - 1, -1, -1):
        state, reward = episode_trajectory[t]
        g = reward + gamma * g
        returns[state].append(g)
        v[state] = np.mean(returns[state])

print("Value function:", v)

关键的概念：

  • episode
    一个情节是指从初始状态到终止状态的一系列状态-动作-奖励的序列
  • episode trajectory
    在一个情节下，智能体与环境交互过程中，包含的一系列状态和相应的奖励；
    这个状态和相应的奖励序列取决于智能体采用什么样的策略，以及环境如何响应这些动作；
  • 更新累计回报
    G t = R t + 1 + γ R t + 2 + . . . + γ R t + 2 T − 1 R T v π ( s ) = E π [ G t ∣ S t = s ] \begin{aligned} G_t &= R_{t+1}+ \gamma R_{t+2}+...+ \gamma R_{t+2}^{T-1}R_T \\ v_{\pi}(s) & = E_{\pi}[G_t|S_t=s] \end{aligned} Gt​vπ​(s)​=Rt+1​+γRt+2​+...+γRt+2T−1​RT​=Eπ​[Gt​∣St​=s]​
  • 对比known MDP和MC
#计算reward,MC
while state != n_states - 1:
    action = np.random.choice(actions, p=policy[state, :])
    next_state, reward = step(state, action)
    episode_trajectory.append((state, reward))
    state = next_state
g = 0
for t in range(len(episode_trajectory) - 1, -1, -1):
    state, reward = episode_trajectory[t]
    g = reward + gamma * g
    returns[state].append(g)
    v[state] = np.mean(returns[state])
#计算reward, DP
# Policy Evaluation
V = np.zeros(n_states)
while True:
    delta = 0
    for state in range(n_states):
        v = V[state]
        V[state] = np.sum(policy[state, :] * (rewards[state, :] + gamma * transition_matrix[state, :, :] @ V))
        delta = max(delta, abs(v - V[state]))
    if delta < theta:
        break

2.2 incremental mean

在这里插入图片描述

2.3 incremental MC updates

在这里插入图片描述
在这里插入图片描述

3 Temporal Difference Learning

3.1 TD methods的特点

  • TD methods learn directly from episodes of experience
  • TD is model free: no knowledge of MDP transitions / rewards
  • TD learns from incomplete episodes, by bootstrapping
  • TD updates a guess towards a guess

3.2 MC 和TD

在这里插入图片描述
用MC解决driving home 的问题

import numpy as np

def generate_episode(policy, n_states, step):
    state = 0
    episode_trajectory = []
    
    while state != n_states - 1:
        action = np.random.choice(actions, p=policy[state, :])
        next_state, reward = step(state, action)
        episode_trajectory.append((state, reward))
        state = next_state
    
    return episode_trajectory

def monte_carlo_policy_evaluation(policy, n_states, n_episodes, step, gamma=1.0):
    returns_sum = np.zeros(n_states)
    returns_count = np.zeros(n_states)
    
    for episode_idx in range(n_episodes):
        episode_trajectory = generate_episode(policy, n_states, step)
        G = 0
        
        for t in range(len(episode_trajectory) - 1, -1, -1):
            state, reward = episode_trajectory[t]
            G = gamma * G + reward
            
            if state not in [x[0] for x in episode_trajectory[:t]]:
                returns_sum[state] += G
                returns_count[state] += 1
    
    value_function = returns_sum / returns_count
    return value_function

# Define the step function for the "Driving Home" problem
def step(state, action):
    next_state = state + (1 if action == 1 else -1)
    next_state = max(0, min(next_state, n_states - 1))  # Make sure we stay within the state bounds
    
    reward = -1
    if next_state == n_states - 1:
        reward = 0

    return next_state, reward

# Define the environment's parameters
n_states = 5
n_actions = 2
actions = np.arange(n_actions)

# Define the initial policy (random policy in this case)
policy = np.ones((n_states, n_actions)) / n_actions

# Run Monte Carlo Policy Evaluation
n_episodes = 1000
value_function = monte_carlo_policy_evaluation(policy, n_states, n_episodes, step)

print("Value Function:", value_function)

TD learning policy的伪代码
α 代表学习律， γ 代表未来权重的折扣因子 \alpha代表学习律，\gamma代表未来权重的折扣因子 α代表学习律，γ代表未来权重的折扣因子
TD learning

Algorithm: TD(0) Policy Evaluation

  1. 初始化值函数 V(s) 对于所有的状态 s，通常将其设置为 0
  2. 初始化策略 pi，确定每个状态采取的动作概率
  3. 选择一个折扣因子 gamma
  4. 对于每一次迭代：
    • a. 初始化状态 s
    • b. 当 s 不是终止状态时：
      • i. 采取由策略 pi 选择的动作 a
      • ii. 从环境中观察到下一个状态 s’ 和奖励 r
      • iii. 更新值函数 V(s) = V(s) + alpha * (r + gamma * V(s’) - V(s))
      • iv. 更新状态 s = s’
import numpy as np

def step(state, action):
    next_state = min(max(state + action, 0), 20)
    reward = -abs(next_state - 10)
    return next_state, reward

n_states = 21
n_actions = 3
actions = np.array([-1, 0, 1])
policy = np.ones((n_states, n_actions)) / n_actions

V = np.zeros(n_states)
alpha = 0.1
gamma = 0.9
n_episodes = 50000

for episode in range(n_episodes):
    state = np.random.randint(0, n_states)
    while state != n_states - 1:
        action = np.random.choice(actions, p=policy[state, :])
        next_state, reward = step(state, action)
        
        td_error = reward + gamma * V[next_state] - V[state]
        V[state] += alpha * td_error
        state = next_state

print("Value Function:")
print(V)

根据GPT4回答，TD相对于MC的好处

TD（Temporal Difference）学习的确将MC（Monte Carlo）中的G(t)替换为r + gamma * V(s’)，这是因为TD学习结合了MC方法和动态规划（DP）的优点。TD学习使用了基于自举（Bootstrapping）的方法，即用当前估计的值函数来更新值函数，这样可以在不知道完整轨迹的情况下进行值函数更新。
相对于MC方法，TD学习具有以下优点：
1.在线学习和实时更新：与MC方法需要等待整个轨迹完>成才能进行值函数更新不同，TD学习可以在线进行，即在每个时间步骤之后立即更新值函数。这使得TD学习更适合实时决策场景。
2.更快的收敛：由于TD学习使用了自举方法，它通常能够更快地收敛到真实值函数，特别是在遇到较长轨迹的情况下。
3.较小的方差：TD学习通常具有较小的方差，因为它不依赖于完整轨迹的返回值，而是使用当前估计的值函数作为更新基础。这使得TD学习的更新通常更稳定。
4.对不完整轨迹的适应性：在某些情况下，观察到的轨迹可能不完整。TD学习可以很好地处理这种情况，因为它不需要完整的轨迹来进行更新。
总的来说，TD学习相对于MC方法具有在线学习、实时更新、更快的收敛速度、较小的方差和对不完整轨迹的适应性等优点。

3.3 bias/variance trade-off

TD的缺点是有偏的估计
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

import numpy as np

# 定义环境参数
n_states = 5
actions = [0, 1]  # 0:不开车, 1:开车
terminal_state = n_states - 1
gamma = 0.9

# 定义策略
policy = np.zeros((n_states, len(actions)))
policy[:, 0] = 1
policy[-1, 1] = 1

# 定义状态转移和奖励函数
def step(state, action):
    if action == 1:
        next_state = min(state + 1, terminal_state)
        reward = -1
    else:
        next_state = state
        reward = -1.5
    return next_state, reward

# 执行 Batch Monte Carlo 策略评估
n_episodes = 10000
V = np.zeros(n_states)
returns = [[] for _ in range(n_states)]

for episode in range(n_episodes):
    state = 0
    episode_trajectory = []

    while state != terminal_state:
        action = np.random.choice(actions, p=policy[state, :])
        next_state, reward = step(state, action)
        episode_trajectory.append((state, reward))
        state = next_state

    G = 0
    for t in range(len(episode_trajectory) - 1, -1, -1):
        state, reward = episode_trajectory[t]
        G = gamma * G + reward
        returns[state].append(G)

# 更新状态值函数
for state in range(n_states):
    if len(returns[state]) > 0:
        V[state] = np.mean(returns[state])

print("Value function:", V)

batch TD learning的policy evaluation的代码

import numpy as np

# 定义环境参数
n_states = 5
n_actions = 2
terminal_state = n_states - 1
gamma = 0.9
n_episodes = 10000
alpha = 0.1

# 定义策略
policy = np.ones((n_states, n_actions)) / n_actions

# 定义状态转换和奖励函数
def step(state, action):
    if action == 0:  # left
        next_state = max(state - 1, 0)
    elif action == 1:  # right
        next_state = min(state + 1, n_states - 1)
    reward = -1 if state != terminal_state else 0
    return next_state, reward

# 初始化值函数
V = np.zeros(n_states)

# 存储每个状态的所有TD误差
td_errors = [[] for _ in range(n_states)]

for _ in range(n_episodes):
    state = 0
    episode_trajectory = []

    while state != terminal_state:
        action = np.random.choice(n_actions, p=policy[state, :])
        next_state, reward = step(state, action)
        episode_trajectory.append((state, action, reward))
        state = next_state

    # 计算每个状态的TD误差并将其添加到相应的列表中
    for t, (state, action, reward) in enumerate(episode_trajectory[:-1]):
        next_state = episode_trajectory[t + 1][0]
        td_error = reward + gamma * V[next_state] - V[state]
        td_errors[state].append(td_error)

# 使用收集到的TD误差计算每个状态的平均值并更新值函数
for state in range(n_states):
    if len(td_errors[state]) > 0:
        V[state] += alpha * np.mean(td_errors[state])

print("Value function:", V)

batch MC和普通MC的区别，在跑完了所有的episode以后再进行V(state)的更新

# 更新状态值函数
for state in range(n_states):
    if len(returns[state]) > 0:
        V[state] = np.mean(returns[state])

那么估计必然会有跑一些episode以后再更新V(state)的策略

3.4 unified view

  • mc backup
    V ( S t ) ← V ( S t ) + α ( G t − V ( S t ) ) V(S_t)\leftarrow V(S_t)+\alpha(G_t-V(S_t)) V(St​)←V(St​)+α(Gt​−V(St​))
    在这里插入图片描述
  • TD
    V ( S t ) ← V ( S t ) + α ( R t + 1 + γ V ( S t + 1 ) − V ( S t ) ) V(S_t) \leftarrow V(S_t)+\alpha (R_{t+1}+\gamma V(S_{t+1}) -V(S_t)) V(St​)←V(St​)+α(Rt+1​+γV(St+1​)−V(St​))
    在这里插入图片描述
  • 动态规划
    在这里插入图片描述
  • bootstrapping and sampling
    在这里插入图片描述
  • 比较各种算法
    在这里插入图片描述

4 TD( λ \lambda λ)

4.1 n step prediction

在这里插入图片描述
在这里插入图片描述

4.2 averaging n-step returns

在这里插入图片描述在这里插入图片描述

4.3 λ \lambda λreturn

希望后面的结果产生的影响更小，采用 λ \lambda λreturn
在这里插入图片描述
在这里插入图片描述

4.4 forward view td

forward view weighting function
G t ( n ) = R t + 1 + γ R t + 2 + . . . + γ n − 1 R t + n + γ n V ( S t + n ) G t λ = ( 1 − λ ) ∑ n = 1 ∞ λ n − 1 G t ( n ) \begin{aligned} G_t^{(n)} & = R_{t+1}+\gamma R_{t+2}+...+\gamma^{n-1} R_{t+n} + \gamma^{n}V(S_{t+n})\\ G_t^{\lambda} &=(1-\lambda)\sum_{n=1}^{\infin}\lambda^{n-1}G_t^{(n)} \\ \end{aligned} Gt(n)​Gtλ​​=Rt+1​+γRt+2​+...+γn−1Rt+n​+γnV(St+n​)=(1−λ)n=1∑∞​λn−1Gt(n)​​

import numpy as np

# 定义环境参数
n_states = 5
n_actions = 2
terminal_state = n_states - 1
gamma = 0.9
n_episodes = 10000
alpha = 0.1
_lambda = 0.9

# 定义策略
policy = np.ones((n_states, n_actions)) / n_actions

# 定义状态转换和奖励函数
def step(state, action):
    if action == 0:  # left
        next_state = max(state - 1, 0)
    elif action == 1:  # right
        next_state = min(state + 1, n_states - 1)
    reward = -1 if state != terminal_state else 0
    return next_state, reward

# 初始化值函数
V = np.zeros(n_states)

for _ in range(n_episodes):
    state = 0
    episode_trajectory = []

    # 生成情节
    while state != terminal_state:
        action = np.random.choice(n_actions, p=policy[state, :])
        next_state, reward = step(state, action)
        episode_trajectory.append((state, reward))
        state = next_state

    T = len(episode_trajectory)
    eligibility_trace = np.zeros(n_states)
    
    # 对每个时间步执行Forward View TD(λ)更新
    for t in range(T):
        current_state, reward = episode_trajectory[t]
        eligibility_trace[current_state] += 1
        G_lambda = 0
        
        for k in range(t, T):
            state_k = episode_trajectory[k][0]
            G_lambda += gamma ** (k - t) * reward * eligibility_trace[state_k]
            eligibility_trace[state_k] *= gamma * _lambda
        
        V[current_state] += alpha * (G_lambda - V[current_state])

print("Value function:", V)

在这里插入图片描述

4.5 backward view TD

在这里插入图片描述

4.5.1 Eligibility traces

E 0 ( s ) = 0 E t ( s ) = γ λ E t − 1 ( s ) + 1 ( s t = s ) \begin{aligned} E_0(s)&=0\\ E_t(s)&=\gamma \lambda E_{t-1}(s)+1(s_t=s) \end{aligned} E0​(s)Et​(s)​=0=γλEt−1​(s)+1(st​=s)​
Eligibility traces的好处是结合了MC和TD的优点，

# TD(0) 算法: no eligibility traces
V = np.zeros(n_states)
for episode in range(n_episodes):
    state = 0
    while state != n_states - 1:
        next_state, reward = step(state)
        V[state] += alpha * (reward + gamma * V[next_state] - V[state])
        state = next_state
# TD(λ)算法
for _ in range(n_episodes):
    state = 2  # 初始状态
    eligibility_trace = np.zeros(n_states)

    while state not in terminal_states:
        action = np.random.choice(n_actions, p=policy[state, :])
        next_state, reward = step(state, action)

        eligibility_trace[state] = eligibility_trace[state] * (gamma * _lambda) + 1

        delta = reward + gamma * V[next_state] - V[state]
        V += alpha * delta * eligibility_trace
        eligibility_trace *= gamma * _lambda

        state = next_state

Eligibility traces的作用

  • 累积效果：通过在每个时间步骤将eligibility trace中的对应状态增加1，我们确保了智能体在同一回合中多次访问同一个状态时，该状态的eligibility trace会累积起来。
  • 衰减效果：通过乘以γ * λ因子，我们在每个时间步骤中都对eligibility trace进行衰减。这意味着距离当前状态越远的状态对更新的贡献会越小。
    在代码中，我们首先对eligibility trace进行衰减，然后再根据当前状态增加1。这样做的原因是我们想要在算法中引入时间差异的信息，即较早出现的状态在更新中的贡献应该较小。因此，当智能体从状态s到达状态s’时，我们首先对eligibility trace[s]进行衰减，然后再将其值增加1。
    通过这种方式，eligibility trace会在每个时间步骤中平衡累积和衰减效果，从而使TD(λ)算法能够利用距离当前状态不同距离的信息来更有效地进行值函数更新。

4.5.2 向后backward的代码

公式
δ t = R t + 1 + γ V ( S t + 1 ) − V ( S t ) \begin{aligned} \delta_t &=R_{t+1}+\gamma V(S_{t+1})-V(S_t) \end{aligned} δt​​=Rt+1​+γV(St+1​)−V(St​)​

import numpy as np

n_states = 5
n_actions = 2
terminal_states = [0, n_states - 1]

# 转移函数
def step(state, action):
    if state in terminal_states:
        return state, 0

    if action == 0:  # 左
        next_state = max(0, state - 1)
    elif action == 1:  # 右
        next_state = min(n_states - 1, state + 1)

    reward = 0 if next_state != n_states - 1 else 1
    return next_state, reward

policy = np.ones((n_states, n_actions)) / n_actions
V = np.zeros(n_states)
n_episodes = 5000
alpha = 0.1
gamma = 0.99
_lambda = 0.9

for _ in range(n_episodes):
    state = 2  # 初始状态
    eligibility_trace = np.zeros(n_states)

    while state not in terminal_states:
        action = np.random.choice(n_actions, p=policy[state, :])
        next_state, reward = step(state, action)

        eligibility_trace[state] = eligibility_trace[state] * (gamma * _lambda) + 1

        delta = reward + gamma * V[next_state] - V[state]
        V += alpha * delta * eligibility_trace
        eligibility_trace *= gamma * _lambda

        state = next_state

print("Estimated state values:")
print(V)

在这里插入图片描述

4.5.3 向前视角和向后视角的区别

向前视角 (Forward View) TD：
向前视角 TD 侧重于观察未来的奖励和状态值。它是基于 n 步 TD 预测的概念，即根据过去 n 个时间步长的奖励和状态值来更新当前状态的值。因此，它需要未来 n 步的信息来进行更新。向前视角 TD 的主要问题是它需要在实际应用中等待 n 步，这可能导致较慢的学习速度。
向后视角 (Backward View) TD：
向后视角 TD 试图通过引入 Eligibility Traces 来解决向前视角 TD 的问题。Eligibility Traces 能够追踪过去状态的访问频率以及它们对当前值函数更新的贡献。向后视角 TD 不需要等待未来 n 步，而是在每个时间步立即更新值函数，这使得它在在线学习中更有效。
联系：
尽管向前视角和向后视角 TD 在实现上有所不同，但它们在理论上是等价的。换句话说，在完整的序列上，它们会收敛到相同的值函数估计。事实上，向后视角 TD 可以被视为向前视角 TD 的一种有效实现。
总之，向前视角和向后视角 TD 都是强化学习中估计值函数的方法，但它们的计算方法和实现方式有所不同。向前视角关注未来的奖励和状态值，而向后视角通过引入 Eligibility Traces 来追踪过去状态的访问频率和它们对当前值函数更新的贡献。虽然它们在实现上有所不同，但在理论上它们是等价的。

4.5.4 TD(0)和TD( λ \lambda λ)

在这里插入图片描述

4.5.5 MC和TD( λ \lambda λ)

在这里插入图片描述

4.6 MC 和TD(1)

E 0 ( s ) = 0 E t ( s ) = γ λ E t − 1 ( s ) + 1 ( s t = s ) \begin{aligned} E_0(s)&=0\\ E_t(s)&=\gamma \lambda E_{t-1}(s)+1(s_t=s) \end{aligned} E0​(s)Et​(s)​=0=γλEt−1​(s)+1(st​=s)​
λ \lambda λ
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

4.7 offline equivalence of forward and backward TD

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/18083.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Android类似微信聊天页面教程(Kotlin)五——选择发送图片

Android类似微信聊天页面教程(Kotlin)五——选择发送图片

前提条件 安装并配置好Android Studio Android Studio Electric Eel | 2022.1.1 Patch 2 Build #AI-221.6008.13.2211.9619390, built on February 17, 2023 Runtime version: 11.0.150-b2043.56-9505619 amd64 VM: OpenJDK 64-Bit Server VM by JetBrains s.r.o. Windows 11 …
阅读更多...
paddleLite在Android部署初体验（环境问题）

paddleLite在Android部署初体验（环境问题）

paddleLite初体验&#xff08;环境问题&#xff09; Android Studio下载Paddle Lite Demo打开项目环境配置下载到手机 Paddle Lite是百度开发的一种方便部署的深度学习推理框架&#xff0c;笔者最近想接触一些模型部署相关项目&#xff0c;就先接触了一下Paddle Lite&#xff0…
阅读更多...
eks实践案例

eks实践案例

Eks&#xff1a; ami-0c23197c88296c1b5 eks集群&#xff1a; 拉面 - 知乎 https://blog.csdn.net/saynaihe/category_12204222.html 什么是 Amazon EKS&#xff1f; - Amazon EKS kubectl 使用指南 https://zhuanlan.zhihu.com/p/364994610 k8s HPA自动伸缩 手把手教你 K8…
阅读更多...
【花雕学AI】我们如何才能避免被ChatGPT替代？——一个跨学科的视角

【花雕学AI】我们如何才能避免被ChatGPT替代？——一个跨学科的视角

ChatGPT是一个由OpenAI开发的AI文本工具&#xff0c;它可以理解和生成自然语言&#xff0c;从而与用户进行对话。ChatGPT是基于GPT-3或者GPT-4模型的&#xff0c;这是目前最大和最先进的语言模型之一。ChatGPT通过在大量的互联网文本数据上进行预训练和强化学习&#xff0c;学习…
阅读更多...
Mongodb 在工业场景下的数字解决方案

Mongodb 在工业场景下的数字解决方案

开头还是介绍一下群&#xff0c;如果感兴趣polardb ,mongodb ,mysql ,postgresql ,redis 等有问题&#xff0c;有需求都可以加群群内有各大数据库行业大咖&#xff0c;CTO&#xff0c;可以解决你的问题。加群请联系 liuaustin3 &#xff0c;在新加的朋友会分到2群&#xff08;共…
阅读更多...
UICollectionView 实现整页翻动（每页3个cell）

UICollectionView 实现整页翻动（每页3个cell）

提示&#xff1a;页面架构是通过UICollectionView做的分页&#xff0c;分页点PageControl使用的是<SDCycleScrollView/TAPageControl.h> &#xff0c;布局架构使用的是Masonry 前言 为了实现UICollectionView无限翻动&#xff0c;连续滑动&#xff0c;主要是利用pagingE…
阅读更多...
2023年计算机视觉与模式识别国际会议(CCVPR 2023)

2023年计算机视觉与模式识别国际会议(CCVPR 2023)

会议简介 Brief Introduction 2023年计算机视觉与模式识别国际会议(CCVPR 2023) 会议时间&#xff1a;2023年9月15日-17日 召开地点&#xff1a;英国牛津 大会官网&#xff1a;www.ccvpr.org 计算机视觉技术与模式识别是现代科学中备受关注的热点技术&#xff0c;它的革新对各行…
阅读更多...
改写句子的软件有哪些-免费改写文章的软件

改写句子的软件有哪些-免费改写文章的软件

改写句子的软件 改写句子的软件是一种广泛应用于文字处理的工具&#xff0c;其主要作用是通过对原文中的语言结构和表述方式进行调整和优化&#xff0c;以改进文章的质量和可读性。改写句子的软件广泛用于新闻报道、科学文章、学术论文、书籍等各类文本材料中&#xff0c;旨在…
阅读更多...
港科夜闻｜广东省委常委、副省长王曦到访香港科技大学

港科夜闻｜广东省委常委、副省长王曦到访香港科技大学

关注并星标 每周阅读港科夜闻 建立新视野 开启新思维 1、广东省委常委、副省长王曦到访香港科技大学。在香港科大校长、粤港澳大湾区院士联盟理事会主席叶玉如教授陪同下&#xff0c;王曦常委率代表团参观国家级科研设施和了解学校发展情况&#xff0c;并与在港中国科学院院士座…
阅读更多...
分享kubernetes部署：cachecloud部署说明

分享kubernetes部署：cachecloud部署说明

cachecloud部署 cachecloud是搜狐视频(sohutv)Redis私有云平台 已省略~ 挑选一台服务器部署cachecloud-web 将cachecloud-web打成war包&#xff0c;可以在服务器上打包&#xff0c;也可以在本地打包&#xff0c;这里举一个在服务器上打包的例子。 将源代码下载到/opt下 已省略~…
阅读更多...
使用 SaleSmartly 实时聊天提高转化率

使用 SaleSmartly 实时聊天提高转化率

在竞争激烈的电子商务环境中&#xff0c;很难给客户留下持久的印象&#xff0c;与他们建立关系更加困难。但是&#xff0c;提供个性化的体验和产品是超越竞争对手的最佳方式之一。这就是为什么许多跨境电子商务企业将与客户的个性化沟通作为他们的首要任务。 SaleSmartly&#…
阅读更多...
【Java数据结构】优先级队列(堆)

【Java数据结构】优先级队列(堆)

优先级队列&#xff08;堆&#xff09; 概念模拟实现堆的概念堆的存储方式堆的创建向下调整堆的创建建堆的时间复杂度 堆的插入和删除堆的插入堆的删除 用堆模拟实现优先级队列 常用接口PriorityQueue的特性PriorityQueue常用接口介绍构造方法插入/删除/获取优先级最高的元素 P…
阅读更多...
Lecture 14：Life-long Learning

Lecture 14：Life-long Learning

目录 Catastrophic Forgetting 灾难性遗忘(Catastrophic Forgetting)的克服之道 Selective Synaptic Plasticity Additional Neural Resource Allocation Memory Reply 其他 Catastrophic Forgetting ——为什么今日的人工智慧无法成为天网&#xff1f;灾难性遗忘 Life…
阅读更多...
2-Lampiao百个靶机渗透（精写-思路为主）框架漏洞利用2

2-Lampiao百个靶机渗透（精写-思路为主）框架漏洞利用2

特别注明&#xff1a;本文章只用于学习交流&#xff0c;不可用来从事违法犯罪活动&#xff0c;如使用者用来从事违法犯罪行为&#xff0c;一切与作者无关。 文章目录 前言一、环境重新部署二、AWVSxray联动和xraybs联动1.安装AWVSxray2.让xray和bs先联动3.AWVS和xray联动 三、p…
阅读更多...
Camtasia2023官方中文版免费下载

Camtasia2023官方中文版免费下载

在现在的网络互联网时代&#xff0c;越来越多的人走上了自媒体的道路。有些自媒体人会自己在网络上录制精彩视频&#xff0c;也有一些人会将精彩、热门的电影剪辑出来再加上自己给它的配音&#xff0c;做成大家喜欢看的电影剪辑片段。相信不管大家是自己平时有独特的爱好也好、…
阅读更多...
欧科云链OKLink：2023年4月安全事件盘点

欧科云链OKLink：2023年4月安全事件盘点

一、基本信息 2023年4月安全事件共造约6000万美金的损失&#xff0c;与上个月相比&#xff0c;损失金额有所降落&#xff0c;但安全事件数量依旧不减。其中&#xff0c;Yearn Finance因参数配置错误&#xff0c;导致了1000多万美金的损失。同时&#xff0c;有一些已经出现过的…
阅读更多...
ZC706P试验PL_DDR3内存条的步骤方法

ZC706P试验PL_DDR3内存条的步骤方法

ZC706P 板卡完全兼容XILINX官方的ZC706,当然也支持PL外挂的1G的DDR3内存条&#xff0c;这个片BLOG我提供从官方下载的一个文档和一个项目&#xff0c;演示一下验证DDR3的步骤。 步骤1&#xff1a;准备好板子&#xff0c;安装好软件。 链接&#xff1a;https://pan.baidu.com/s…
阅读更多...
JVM原理与实战（一）

JVM原理与实战（一）

jvm的基本结构 1.类加载系统 负责从文件系统或者网络中加载Class信息 2.方法区 &#xff08;1&#xff09;加载的类信息存放于一块称为方法去的内存空间 &#xff08;2&#xff09;除了类的信息外&#xff0c;方法区中可能还存放着运行时常量池信息&#xff0c;包括字符串字面…
阅读更多...
什么是皮安计？皮安表测试测量软件分享NS-SourceMeter

什么是皮安计？皮安表测试测量软件分享NS-SourceMeter

什么是皮安计 测量低直流电流&#xff0c;其需求常常远远超出数字万用表的功能。一般来说&#xff0c;数字万用表缺少测量低于100nA的电流所需的灵敏度。即使在较高的电流水平上&#xff0c;一个DMM的输入电压降&#xff08;电压负担&#xff09;高达几百毫伏&#xff0c;也不…
阅读更多...
DD驱动鼠标键盘(驱动级别机器人使用鼠标键盘)

DD驱动鼠标键盘(驱动级别机器人使用鼠标键盘)

官网下载 DD虚拟键盘虚拟鼠标 github下载 GitHub - ddxoft/master 点击下载后&#xff0c;将驱动包下&#xff0c;这里以win7为例 setup运行安装 安装成功后 可以打开电脑管理&#xff0c;可以看见DD虚拟鼠标和键盘 这里以JAVA接入为例 使用管理员权限启动eclipse &#…
阅读更多...
最新文章

Copyright @ 2022~2023