改进代码，def take_action( s): # 选取下一步的操作 if np.random.random() < epsilon: action = np.random.randint(n_action) # def take_action(self, s): # 选取下一步的操作 # (x0,y0)=s0 # a0为向下，a1为向上，a2为向左，a3为向右 # change = [[0, -step], [0, step], [-step, 0], [step, 0]] # F_actions = [] else: change = [[0, -step_action], [0, step_action], [-step_action, 0], [step_action, 0]] F_actions = [] for i in range(4): next_state_action = np.array(s[0]) + np.array(change[i]) # 有点问题np.array把列表转为数组 (x1, y1) = next_state_action F_next_state__actions = x1 ** 2 + y1 ** 2 F_actions.append(F_next_state__actions) action = np.argmin(F_actions) print('动作值', F_actions) print('动作：', action) return action

SyntaxError: invalid syntax def take_action(self, s): #选取下一步的操作 if np.random.random() < self.epsilon: action = np.random.randint(self.n_action) # def take_action(self, s): # 选取下一步的操作 # (x0,y0)=s0 # a0为向下，a1为向上，a2为向左，a3为向右 change = [[0, -step], [0, step], [-step, 0], [step, 0]] F_actions = [] else: for i in range(4): next_state_action = s[0] + np.array(change[i]) # 有点问题np.array # print(s[0]) # print(next_state_action) (x, y) = next_state_action F_next_actions = F(x, y) F_actions.append(F_next_actions) action = np.argmax(F_actions) print('动作：',action) return action

if np.random.random() < self.epsilon: action = np.random.randint(self.n_action) else: # (x0,y0)=s0 # a0为向下，a1为向上，a2为向左，a3为向右 change = [[0, -step], [0, step], [-step, 0], [step...

请解释以下代码：# 根据输入观察值，采样输出的动作值，有一定概率采取随机动作（探索） def sample(self, obs): if np.random.uniform(0, 1) < (1.0 - self.epsilon): #根据table的Q值选动作 action = self.predict(obs) else: action = np.random.choice(self.act_n) #有一定概率随机探索选取一个动作 return action

如果生成的随机数大于等于1.0减去epsilon的值，则以epsilon的概率进行随机探索，通过np.random.choice(self.act_n)来从动作空间中随机选择一个动作。最后，返回选取的动作值。这样，根据epsilon-greedy策略，在...

def fuzzy_kmeans(data, num_clusters, m, max_iter=100, epsilon=1e-4): num_samples = data.shape[0] num_features = data.shape[1] # 初始化隶属度矩阵 membership = np.random.dirichlet(np.ones(num_clusters), size=num_samples) # 迭代更新聚类中心和隶属度 for iter in range(max_iter): # 计算聚类中心 centers = np.zeros((num_clusters, num_features)) for k in range(num_clusters): centers[k] = np.sum((membership[:, k]**m).reshape(-1, 1) * data, axis=0) / np.sum(membership[:, k]m) # 计算隶属度 new_membership = np.zeros((num_samples, num_clusters)) for i in range(num_samples): for k in range(num_clusters): numerator = np.linalg.norm(data[i] - centers[k]) denominator = np.sum([(np.linalg.norm(data[i] - centers[j]) / numerator)(2 / (m - 1)) for j in range(num_clusters)]) new_membership[i, k] = 1 / denominator # 判断迭代终止条件 if np.sum(np.abs(new_membership - membership)) < epsilon: break membership = new_membership return centers, membership

这是一个模糊k-means聚类算法的Python实现。该算法使用隶属度矩阵来描述每个数据点属于每个聚类中心的隶属度程度。具体步骤如下： 1. 初始化隶属度矩阵，使用Dirichlet分布生成每个数据点属于每个聚类中心的隶属度...

import tensorflow as tf import numpy as np import gym # 创建 CartPole 游戏环境 env = gym.make('CartPole-v1') # 定义神经网络模型 model = tf.keras.models.Sequential([ tf.keras.layers.Dense(24, activation='relu', input_shape=(4,)), tf.keras.layers.Dense(24, activation='relu'), tf.keras.layers.Dense(2, activation='linear') ]) # 定义优化器和损失函数 optimizer = tf.keras.optimizers.Adam() loss_fn = tf.keras.losses.MeanSquaredError() # 定义超参数 gamma = 0.99 # 折扣因子 epsilon = 1.0 # ε-贪心策略中的初始 ε 值 epsilon_min = 0.01 # ε-贪心策略中的最小 ε 值 epsilon_decay = 0.995 # ε-贪心策略中的衰减值 batch_size = 32 # 每个批次的样本数量 memory = [] # 记忆池 # 定义动作选择函数 def choose_action(state): if np.random.rand() < epsilon: return env.action_space.sample() else: Q_values = model.predict(state[np.newaxis]) return np.argmax(Q_values[0]) # 定义经验回放函数 def replay(batch_size): batch = np.random.choice(len(memory), batch_size, replace=False) for index in batch: state, action, reward, next_state, done = memory[index] target = model.predict(state[np.newaxis]) if done: target[0][action] = reward else: Q_future = np.max(model.predict(next_state[np.newaxis])[0]) target[0][action] = reward + Q_future * gamma model.fit(state[np.newaxis], target, epochs=1, verbose=0) # 训练模型 for episode in range(1000): state = env.reset() done = False total_reward = 0 while not done: action = choose_action(state) next_state, reward, done, _ = env.step(action) memory.append((state, action, reward, next_state, done)) state = next_state total_reward += reward if len(memory) > batch_size: replay(batch_size) epsilon = max(epsilon_min, epsilon * epsilon_decay) print("Episode {}: Score = {}, ε = {:.2f}".format(episode, total_reward, epsilon))next_state, reward, done, _ = env.step(action) ValueError: too many values to unpack (expected 4)优化代码

if np.random.rand() < epsilon: return env.action_space.sample() else: Q_values = model.predict(state[np.newaxis]) return np.argmax(Q_values[0]) # 定义经验回放函数 def replay(batch_size): ...

帮我接下去写class Result: def first_function(x: float, y: float): return math.sin(x) def second_function(x: float, y: float): return (x * y)/2 def third_function(x: float, y: float): return y - (2 * x)/y def fourth_function(x: float, y: float): return x + y def default_function(x:float, y: float): return 0.0 # How to use this function: # func = Result.get_function(4) # func(0.01) def get_function(n: int): if n == 1: return Result.first_function elif n == 2: return Result.second_function elif n == 3: return Result.third_function elif n == 4: return Result.fourth_function else: return Result.default_function # # Complete the 'solveByMilne' function below. # # The function is expected to return a DOUBLE. # The function accepts following parameters: # 1. INTEGER f # 2. DOUBLE epsilon # 3. DOUBLE a # 4. DOUBLE y_a # 5. DOUBLE b # def solveByMilne(f, epsilon, a, y_a, b):

以下是完整的代码： python import math class Result: def first_function(x: float, y: float): return math.sin(x) def second_function(x: float, y: float): return (x * y)/2 def third_...

import akshare as ak import numpy as np import pandas as pd import random import matplotlib.pyplot as plt class StockTradingEnv: def init(self): self.df = ak.stock_zh_a_daily(symbol='sh000001', adjust="qfq").iloc[::-1] self.observation_space = self.df.shape[1] self.action_space = 3 self.reset() def reset(self): self.current_step = 0 self.total_profit = 0 self.done = False self.state = self.df.iloc[self.current_step].values return self.state def step(self, action): assert self.action_space.contains(action) if action == 0: # 买入 self.buy_stock() elif action == 1: # 卖出 self.sell_stock() else: # 保持不变 pass self.current_step += 1 if self.current_step >= len(self.df) - 1: self.done = True else: self.state = self.df.iloc[self.current_step].values reward = self.get_reward() self.total_profit += reward return self.state, reward, self.done, {} def buy_stock(self): pass def sell_stock(self): pass def get_reward(self): pass class QLearningAgent: def init(self, state_size, action_size): self.state_size = state_size self.action_size = action_size self.epsilon = 1.0 self.epsilon_min = 0.01 self.epsilon_decay = 0.995 self.learning_rate = 0.1 self.discount_factor = 0.99 self.q_table = np.zeros((self.state_size, self.action_size)) def act(self, state): if np.random.rand() <= self.epsilon: return random.randrange(self.action_size) else: return np.argmax(self.q_table[state, :]) def learn(self, state, action, reward, next_state, done): target = reward + self.discount_factor * np.max(self.q_table[next_state, :]) self.q_table[state, action] = (1 - self.learning_rate) * self.q_table[state, action] + self.learning_rate * target if self.epsilon > self.epsilon_min: self.epsilon *= self.epsilon_decay env = StockTradingEnv() agent = QLearningAgent(env.observation_space, env.action_space) for episode in range(1000): state = env.reset() done = False while not done: action = agent.act(state) next_state, reward, done, _ = env.step(action) agent.learn(state, action, reward, next_state, done) state = next_state if episode % 10 == 0: print("Episode: %d, Total Profit: %f" % (episode, env.total_profit)) agent.save_model("model-%d.h5" % episode) def plot_profit(env, title): plt.figure(figsize=(12, 6)) plt.plot(env.df.index, env.df.close, label="Price") plt.plot(env.df.index, env.profits, label="Profits") plt.legend() plt.title(title) plt.show() env = StockTradingEnv() agent = QLearningAgent(env.observation_space, env.action_space) agent.load_model("model-100.h5") state = env.reset() done = False while not done: action = agent.act(state) next_state, reward, done, _ = env.step(action) state = next_state plot_profit(env, "QLearning Trading Strategy")优化代码

1. 对于环境类 StockTradingEnv，可以考虑将 buy_...5. 可以将 QLearningAgent 类中的方法进行整理和封装，提高代码的可读性和可维护性。同时，也可以添加一些对模型进行保存和加载的方法，便于模型的重用和共享。

def add_noise(image, epsilon, k): # 添加拉普拉斯噪声 # 进行离散傅里叶变换 f = np.fft.fft2(image) # 将零频率分量移到频谱中心 fshift = np.fft.fftshift(f) rows, cols = image.shape b = laplas(fshift, epsilon, k) # print(b) p = 0.5 noise = np.random.laplace(scale=b, size=(rows, cols)) + np.mean(f) * p # noise = np.random.laplace(0, 1/b, (rows, cols)) image_noise = fshift + noise f_ishift = np.fft.ifftshift(image_noise) # 进行逆离散傅里叶变换 image_back = np.fft.ifft2(f_ishift) image_back = np.real(image_back) return image_back def laplas(FIM, epsilon, k): FIM_k = FIM[:k, :k] # 给定隐私预算 epsilon # 计算给定隐私预算时的拉普拉斯机制的参数的最小值 # 计算每个系数的灵敏度 sensitivity = np.abs(FIM_k) / np.sqrt(epsilon) sensitivity2 = np.abs(FIM) / np.sqrt(epsilon) scale = sensitivity2 / epsilon # 计算拉普拉斯机制的参数 # 计算前 k×k 个 DFT 系数的最大值和最小值之差 delta_f = np.max(np.sqrt(np.real(FIM[:k, :k]) 2 + np.imag(FIM[:k, :k]) 2)) - np.min( np.sqrt(np.real(FIM[:k, :k]) 2 + np.imag(FIM[:k, :k]) 2)) # 计算拉普拉斯噪声的尺度参数 c = delta_f / epsilon d = delta_f * math.sqrt(2 * math.log(1.25 / 0.1)) / epsilon # a = np.min(sensitivity) / (epsilon * k**2) return d def add_noisy_image(): # 读取人脸图像 image = cv2.imread("image.jpg", cv2.IMREAD_GRAYSCALE) image = cv2.resize(image, (128, 128), interpolation=cv2.INTER_LINEAR) # 进行离散傅里叶变换 epsilon = 0.3 k = 50 image_back = add_noise(image, epsilon, k) im = cv2.resize(image_back, (47, 62), interpolation=cv2.INTER_LINEAR) # 将图像转换为整型并保存 image_back = np.uint8(im) cv2.imwrite("face_privacy.jpg", image_back) return image_back

delta_f = np.max(np.sqrt(np.real(FIM[:k, :k]) ** 2 + np.imag(FIM[:k, :k]) ** 2)) - np.min( np.sqrt(np.real(FIM[:k, :k]) ** 2 + np.imag(FIM[:k, :k]) ** 2)) c = delta_f / epsilon d = delta_f * math....

self.epsilon = np.random.randn(self.popsize, self.num_params) * self.sigma

这段代码使用了numpy库中的random.randn函数生成一个形状为(self.popsize, self.num_params)的随机数组，每个元素都是从标准正态分布中随机抽取得到的。然后将这个随机数组乘以self.sigma，得到的结果赋值给了self....

def add_noise(image, epsilon, k): f = np.fft.fft2(image) fshift = np.fft.fftshift(f) rows, cols = image.shape b = laplas(fshift, epsilon, k) # print(b) p = 0.5 noise = np.random.laplace(scale=b, size=(rows, cols)) + np.mean(f) * p image_noise = fshift + noise f_ishift = np.fft.ifftshift(image_noise) image_back = np.fft.ifft2(f_ishift) image_back = np.real(image_back) return image_back def laplas(FIM, epsilon, k): FIM_k = FIM[:k, :k] sensitivity = np.abs(FIM_k) / np.sqrt(epsilon) sensitivity2 = np.abs(FIM) / np.sqrt(epsilon) scale = sensitivity2 / epsilon delta_f = np.max(np.sqrt(np.real(FIM[:k, :k]) 2 + np.imag(FIM[:k, :k]) 2)) - np.min( np.sqrt(np.real(FIM[:k, :k]) 2 + np.imag(FIM[:k, :k]) 2)) c = delta_f / epsilon d = delta_f * math.sqrt(2 * math.log(1.2 / 0.1)) / epsilon return d def add_noisy_image(): image = cv2.imread("image.jpg", cv2.IMREAD_GRAYSCALE) image = cv2.resize(image, (128, 128), interpolation=cv2.INTER_LINEAR) epsilon = 0.3 k = 50 image_back = add_noise(image, epsilon, k) im = cv2.resize(image_back, (47, 62), interpolation=cv2.INTER_LINEAR) image_back = np.uint8(im) cv2.imwrite("face_privacy.jpg", image_back) return image_back

delta_f = np.max(np.sqrt(np.real(FIM[:k, :k]) ** 2 + np.imag(FIM[:k, :k]) ** 2)) - np.min(np.sqrt(np.real(FIM[:k, :k]) ** 2 + np.imag(FIM[:k, :k]) ** 2)) c = delta_f / epsilon d = delta_f * math....

lr = 2e-3 num_episodes = 500 hidden_dim = 128 gamma = 0.98 epsilon = 0.01 target_update = 10 buffer_size = 10000 minimal_size = 500 batch_size = 64 device = torch.device("cuda") if torch.cuda.is_available() else torch.device( "cpu") env_name = 'CartPole-v1' env = gym.make(env_name) random.seed(0) np.random.seed(0) #env.seed(0) torch.manual_seed(0) replay_buffer = ReplayBuffer(buffer_size) state_dim = env.observation_space.shape[0] action_dim = env.action_space.n agent = DQN(state_dim, hidden_dim, action_dim, lr, gamma, epsilon, target_update, device) return_list = [] episode_return = 0 state = env.reset()[0] done = False while not done: action = agent.take_action(state) next_state, reward, done, _, _ = env.step(action) replay_buffer.add(state, action, reward, next_state, done) state = next_state episode_return += reward # 当buffer数据的数量超过一定值后,才进行Q网络训练 if replay_buffer.size() > minimal_size: b_s, b_a, b_r, b_ns, b_d = replay_buffer.sample(batch_size) transition_dict = { 'states': b_s, 'actions': b_a, 'next_states': b_ns, 'rewards': b_r, 'dones': b_d } agent.update(transition_dict) if agent.count >=200: #运行200步后强行停止 agent.count = 0 break return_list.append(episode_return) episodes_list = list(range(len(return_list))) plt.plot(episodes_list, return_list) plt.xlabel('Episodes') plt.ylabel('Returns') plt.title('DQN on {}'.format(env_name)) plt.show()对上述代码的每一段进行注释，并将其在段落中的作用注释出来

action = agent.take_action(state) # 智能体根据当前状态选择动作 next_state, reward, done, _, _ = env.step(action) # 环境执行动作，观测下一个状态、奖励和结束标志 replay_buffer.add(state, action, ...

def select_action(self, state): if state[-1] >= 140: return 1 if random.random() < self.epsilon: return random.randrange(self.output_dim) else: robot_angle = state[2] dust_angle = state[5] angle_dis = robot_angle - dust_angle if angle_dis < 0: return 0 elif angle_dis > 0: return 2 else: return 1

接下来，函数通过随机数与epsilon值进行比较，如果小于epsilon，函数将随机选择一个动作返回。否则，函数计算机器人角度和灰尘角度之间的差值，并根据差值的结果返回相应的动作。如果差值小于0，函数返回0；如果差值...

检查下面代码中的错误并修改# -- coding: UTF-8 -- import numpy as np import matplotlib.pyplot as plt # 设置信道错误概率p和码率R p = 0.01 R = 1000 # 设置典型集参数epsilon和n epsilon = 0.01 n = 10 # 生成随机序列 np_random_sequence = np.random.randint(0, 10000, size=R) # 接收比特 data = np.zeros((R, n)) data[np.where(np.random.rand(R, n) < p)] = 1 # 进行解码 decoded = np.zeros((R, n)) decoded[np.where(np.random.rand(R, n) < p)] = 1 # 仿真性能 P_a = np.sum(data != decoded, axis=1) / n * 100 P_b = np.sum(data != decoded, axis=1) / n * 100 # 绘制性能曲线 plt.plot(np.arange(1, R+1, 1) * R / n, P_a, label='A') plt.xlabel('Time (s)') plt.ylabel('错误率') plt.title('Random 编码 (p = 0.01, R = 1000)') plt.show() # 绘制性能曲线 plt.plot(np.arange(1, R+1, 1) * R / n, P_b, label='B') plt.xlabel('Time (s)') plt.ylabel('错误率') plt.title('Random 编码 (p = 0.01, R = 1000)') plt.show()

data[np.where(np.random.rand(R, n) < p)] = 1 # 进行解码 decoded = np.zeros((R, n)) decoded[np.where(np.random.rand(R, n) < p)] = 1 # 仿真性能 P_a = np.sum(data != decoded, axis=1) / n * 100 P_b = np...

np.random.uniform()>EPSILON

np.random.uniform()函数用于产生一个0-1之间的随机数。...这段代码会根据np.random.uniform()生成的随机数与EPSILON进行比较，如果大于EPSILON，则输出"Random action"；否则输出"Non-random action"。

def add_noisy_image(image_path, output_path, epsilon=0.3, k=50): # 读取图片并调整大小 image = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE) image = cv2.resize(image, (128, 128), interpolation=cv2.INTER_LINEAR) # 对图片添加噪声 f = np.fft.fft2(image) fshift = np.fft.fftshift(f) rows, cols = image.shape FIM = fshift FIM_k = FIM[:k, :k] delta_f = np.max(np.sqrt(np.real(FIM[:k, :k]) 2 + np.imag(FIM[:k, :k]) 2)) - np.min(np.sqrt(np.real(FIM[:k, :k]) 2 + np.imag(FIM[:k, :k]) 2)) c = delta_f / epsilon d = delta_f * math.sqrt(2 * math.log(1.2 / 0.1)) / epsilon sensitivity = np.abs(FIM_k) / np.sqrt(epsilon) sensitivity2 = np.abs(FIM) / np.sqrt(epsilon) scale = sensitivity2 / epsilon b = d * scale p = 0.5 noise = np.random.laplace(scale=b, size=(rows, cols)) + np.mean(f) * p image_noise = fshift + noise f_ishift = np.fft.ifftshift(image_noise) image_back = np.fft.ifft2(f_ishift) image_back = np.real(image_back) # 调整大小并保存图片 im = cv2.resize(image_back, (47, 62), interpolation=cv2.INTER_LINEAR) image_back = np.uint8(im) cv2.imwrite(output_path, image_back) return image_back

这段代码实现了给一张图像添加拉普拉斯噪声的功能，具体实现步骤如下： 1. 读取一张灰度图像，并将其调整为 $128\times128$ 大小的图像。 2. 对图像进行傅里叶变换，得到频率域信息。 3. 根据输入参数 $k$，取频率...

def epsilon_greedy(Q, state, nA, epsilon): # 函数首先判断是否进行探索或贪心动作。如果随机数大于 epsilon，则选择 Q 值最大的动作；否则，随机选择一个动作。最后，返回所选动作。 ''' Q: Q value table state: current statenA: the number of actionepsilon:possibity of exploration return: return selected action ''' # judge exploration or greedy action if random.random() > epsilon: return np.argmax(Q[state]) else: return random.choice(np.arange(nA))

具体来说，如果随机数大于epsilon，则返回在Q表中对应状态state下Q值最大的动作（利用np.argmax函数实现），这是一种贪心策略。如果随机数小于等于epsilon，则返回在nA个动作中随机选择的一个动作，这是一种探索策略...

找出下面代码中的错误并改正import numpy as np import matplotlib.pyplot as plt # 设置信道错误概率p和码率R p = 0.01 R = 1000 # 设置典型集参数epsilon和n epsilon = 0.01 n = 10 # 生成随机序列 np_random_sequence = np.random.randint(0, 10000, size=R) # 接收比特 data = np.zeros((R, n)) data[np.where(np.random.rand(n) < p), :] = 1 # 进行解码 decoded = np.zeros((R,)) decoded[np.where(np.random.rand(n) < p), :] = 0 # 仿真性能 for i in range(R): # 计算平均错误概率和最大错误概率 P(a) = (data[i, :] - Decoded[i, :]) / (data[i, :] - Decoded[i, :]) * 100 P(b) = (data[i, :] - Decoded[i, :]) / (data[i, :] - Decoded[i, :]) * 100 # 绘制性能曲线 plt.plot(np.arange(i + 1, R, i + 1) * R / n, P(a), label='A') plt.xlabel('Time (s)') plt.ylabel('的错误率') plt.title('Random 编码 (p = 0.01, R = 1000)') plt.show() # 绘制性能曲线 plt.plot(np.arange(i + 1, R, i + 1) * R / n, P(b), label='B') plt.xlabel('Time (s)') plt.ylabel('的错误率') plt.title('Random 编码 (p = 0.01, R = 1000)') plt.show()

data[np.where(np.random.rand(R, n) < p)] = 1 # 进行解码 decoded = np.zeros((R, n)) decoded[np.where(np.random.rand(R, n) < p)] = 1 # 仿真性能 P_a = np.sum(data != decoded, axis=1) / n * 100 P_b = np...

解释这段代码 def test(self): returns = [] for time_step in tqdm(range(self.args.time_steps)): episode_step = 0 s = self.env.reset() rewards = np.array([0.0]) while True: u = [] actions = [] with torch.no_grad(): #for agent_id, agent in enumerate(self.agents): action1 = action2 = action3 = action4 = self.action0 action5 = self.agents.select_action(s, self.noise, self.epsilon) + self.action0 # 变道车动作 action = [action1, action2, action3, action4, action5] u.append(action5) # actions.append(action) episode_step += 1 s_next, r, done, info = self.env.step(action) s = s_next rewards = rewards + r# [:-1] if done[0] or episode_step % self.episode_limit == 0: returns.append(rewards) print("Episode:{}, Agent_1:{}".format(time_step, rewards)) break

这段代码是一个测试方法，用于测试智能体在环境中执行任务的效果。它首先通过一个for循环迭代环境中的时间步，然后在每个时间步中，重置环境状态并开始执行一个episode。在每个episode中，智能体根据当前状态选择一...

相关推荐

ARMA.rar_ARMA_c++arma::_时间序列_时间序列分析

Main_SVR_Epsilon.rar_EPSILON_SV_matlab epsilon_one class_svr的eps

DBSCAN.rar_DBSCAN_DBSCAN MATLAB_dbscan matlab_dbscan matlab_s

self.epsilon = np.random.randn(self.popsize, self.num_params) * self.sigma

def select_action(self, state): if state[-1] >= 140: return 1 if random.random() < self.epsilon: return random.randrange(self.output_dim) else: robot_angle = state[2] dust_angle = state[5] angle_dis = robot_angle - dust_angle if angle_dis < 0: return 0 elif angle_dis > 0: return 2 else: return 1

np.random.uniform()>EPSILON

大家在看

VITA 62.0.docx

新项目基于YOLOv8的人员溺水检测告警监控系统python源码(精确度高)+模型+评估指标曲线+精美GUI界面.zip

公安大数据零信任体系设计要求.pdf

批量标准矢量shp互转txt工具

HN8145XR-V5R021C00S260

最新推荐

vb图书馆管理系统(源代码+论文)(20245j).7z

VB通用C++试题库系统的设计与开发(论文+源代码)(2024af).7z

S7-PDIAG工具使用教程及技术资料下载指南

管理建模和仿真的文件

CC-LINK远程IO模块AJ65SBTB1现场应用指南：常见问题快速解决

python 画一个进度条

Nginx 1.19.0版本Windows服务器部署指南

"互动学习：行动中的多样性与论文攻读经历"

CC-LINK远程IO模块在环境监控中的应用：技术与案例探讨

Linux C开发中，如何判断open()函数创建的fd没有被close()