总而言之
，问题是“*”！ *在集数阵列的成员中找到的 *是为什么您每次都会获得相同的数组的原因。
详细信息
regexp 是一个概念开发人员很难理解（我是这样的顺便说一句）。
我将从 regexp on mdn
REGEXP是用于匹配字符串中字符组合的模式-MDN
您想了解代码发生的事情。
当您创建诸如/a*/测试“ AA3” 之类的正则>时，将匹配的是 a ， aa aa < /代码>等。这是JavaScript中的真实性。您可能希望与或 $ 或严格与 \ d \ d /a>。
我将您的代码重写为以下功能：
arr = [
["AA*", "ABC", "XYZ"],
["A*", "AXY", "AAJ"],
];
findInArray(arr, "AA3") // prints both array
findInArray(arr, "AAJ") // prints second array
findInArray(arr, "ABC") // prints first array
function findInArray(array, value) {
return array.filter((subArray) =>
subArray.some((item) => {
const check = new RegExp(value);
return check.test(item);
})
);
}
我认为您忘记了 value 属性，如果您使用React Hooks，也许您可以做这样的事情：
import { useState } from "react";
const [inputValue, setInputValue] = useState("");
...
<input className="input" type="number" placeholder="$" onChange={(evt) => setInputValue(evt.target.value / coinId.price)} value={inputValue} />```
您可以做的是首先为新列“想要”设置一个值
mtcars$want <- 2
library(dplyr)
mtcars %>%
mutate(want = ifelse(carb == 1, qsec, want)) %>%
head(5)
#> mpg cyl disp hp drat wt qsec vs am gear carb want
#> Mazda RX4 21.0 6 160 110 3.90 2.620 16.46 0 1 4 4 2.00
#> Mazda RX4 Wag 21.0 6 160 110 3.90 2.875 17.02 0 1 4 4 2.00
#> Datsun 710 22.8 4 108 93 3.85 2.320 18.61 1 1 4 1 18.61
#> Hornet 4 Drive 21.4 6 258 110 3.08 3.215 19.44 1 0 3 1 19.44
#> Hornet Sportabout 18.7 8 360 175 3.15 3.440 17.02 0 0 3 2 2.00
。
在Swift 5.0+中，
let ids = [1, 2]
let idsString = ids.map { id -> String in
return "{\"packageId\"" + ":" + "\"\(id)\"}"
}.joined(separator: ",")
let result = "[" + idsString + "]"
print(result)
您将获得结果：
[{“ packageid”：“ 1”}，{“ packageid”：“ 2”}]
我遵循了Larnu在OP评论中的建议，并将SQL脚本调整到下面，这是我所需要的
WITH EndsMarked
AS
(SELECT F.Asset_Id
, F.Status_Id
, F.Creation_Date
, CASE
WHEN LAG(F.Status_Id, 1) OVER (PARTITION BY F.Asset_Id
ORDER BY F.Asset_Id
, F.Creation_Date
) IS NULL
AND ROW_NUMBER() OVER (PARTITION BY F.Asset_Id
ORDER BY F.Creation_Date
) = 1 THEN 1
WHEN LAG(F.Status_Id, 1) OVER (PARTITION BY F.Asset_Id
ORDER BY F.Asset_Id
, F.Creation_Date
) <> LAG(F.Status_Id, 0) OVER (PARTITION BY F.Asset_Id
ORDER BY F.Asset_Id
, F.Creation_Date
) THEN 1
ELSE 0
END AS IS_START
, CASE
WHEN LEAD(F.Status_Id, 1) OVER (PARTITION BY F.Asset_Id
ORDER BY F.Asset_Id
, F.Creation_Date
) IS NULL
AND ROW_NUMBER() OVER (PARTITION BY F.Asset_Id
ORDER BY F.Creation_Date DESC
) = 1 THEN 1
WHEN LEAD(F.Status_Id, 0) OVER (PARTITION BY F.Asset_Id
ORDER BY F.Asset_Id
, F.Creation_Date
) <> LEAD(F.Status_Id, 1) OVER (PARTITION BY F.Asset_Id
ORDER BY F.Asset_Id
, F.Creation_Date
) THEN 1
ELSE 0
END AS IS_END
FROM
(
SELECT mrsabda.Assets_AssetId AS Asset_Id
, mrsabda.CreationDate AS Creation_Date
, mrsabda.Assets_Asset_StatusId AS Status_Id
--,[Aantal Facturen]
FROM MRR.MRR_Round_Status_Audit_Buildup_Dim_Asset AS mrsabda
) AS F )
, GroupsNumbered
AS
(SELECT EndsMarked.Asset_Id
, EndsMarked.Status_Id
, EndsMarked.Creation_Date
, EndsMarked.IS_START
, EndsMarked.IS_END
, COUNT( CASE
WHEN EndsMarked.IS_START = 1 THEN 1
END
) OVER (ORDER BY EndsMarked.Asset_Id
, EndsMarked.Creation_Date
) AS GroupNum
FROM EndsMarked
WHERE EndsMarked.IS_START = 1
OR EndsMarked.IS_END = 1)
SELECT a.Asset_Id
, a.Status_Id
, a.GROUP_START AS Start_Date
, DATEADD(SECOND, -1, LEAD(a.GROUP_START, 1, '2099-12-31 00:00:01') OVER (ORDER BY a.GROUP_START)) AS End_Date
FROM
(
SELECT GroupsNumbered.Asset_Id
, GroupsNumbered.Status_Id
, MIN(GroupsNumbered.Creation_Date) AS GROUP_START
, MAX(GroupsNumbered.Creation_Date) AS GROUP_END
FROM GroupsNumbered
GROUP BY GroupsNumbered.Asset_Id
, GroupsNumbered.Status_Id
, GroupsNumbered.GroupNum
) AS a
GROUP BY a.Asset_Id
, a.Status_Id
, a.GROUP_START
首先通过使用
<?php
$dirs = array_filter(glob('*'), 'is_dir');
//print_r($dirs);
?>
并在每个文件夹中使用循环查看
<?php foreach($dirs as $key) { ?>
\\your code as you required.
<? } ?>
目录中的文件列表，从而 获取目录的目录列表“ rel =“ nofollow noreferrer”>单击
更新您的 targualResponse 模型类以相应地解析数据。
data class CharacterResponse(
val info: Info,
val results: List<Characters>
)
错误原因
@newbie评论中正确说明的 ，问题不是模型本身，而是CUDA上下文。当新的子进程分叉时，父母的内存将与孩子共享，但是CUDA上下文不支持此共享，必须向孩子复制。因此，它报告了上述错误。
Spawn 而不是 fork
要解决此问题，我们必须将子进程的开始方法从 fork spawn 带有多处理.set_start_method 。以下简单示例正常工作：
import torch
import torch.multiprocessing as mp
def f(y):
y[0] = 1000
if __name__ == '__main__':
x = torch.zeros(1).cuda()
x.share_memory_()
mp.set_start_method('spawn')
p = mp.Process(target=f, args=(x,), daemon=True)
p.start()
p.join()
print("x =", x.item())
在运行此代码时，初始化了第二个CUDA上下文（可以在第二个窗口中通过观看-N 1 NVIDIA -SMI 观察），以及 f < f < /代码>在上下文完全初始化后执行。此后， x = 1000.0 在控制台上打印出来，因此，我们确认张量 x 在过程之间成功共享。
但是，Gunicorn内部使用 os.fork 来启动工作过程，因此 Multiprocessing.set_start_method 对Gunicorn的行为没有影响。因此，必须避免在根过程中初始化CUDA上下文。
为了在工作过程中共享模型的解决方案
，我们必须将模型加载到一个过程中并与工人共享。幸运的是，通过 torch.multiprocessing.queue 将CUDA张量发送到另一个过程不会复制GPU上的参数，因此我们可以将这些队列用于此问题。
import time
import torch
import torch.multiprocessing as mp
def f(q):
y = q.get()
y[0] = 1000
def g(q):
x = torch.zeros(1).cuda()
x.share_memory_()
q.put(x)
q.put(x)
while True:
time.sleep(1) # this process must live as long as x is in use
if __name__ == '__main__':
queue = mp.Queue()
pf = mp.Process(target=f, args=(queue,), daemon=True)
pf.start()
pg = mp.Process(target=g, args=(queue,), daemon=True)
pg.start()
pf.join()
x = queue.get()
print("x =", x.item()) # Prints x = 1000.0
对于Gunicorn Server，我们可以使用相同的策略：模型服务器进程加载模型并将其用于每个新工作后的叉子后。在 post_fork 挂钩工作者请求并从模型服务器接收模型。 Gunicorn配置看起来像这样：
import logging
from client import request_model
from app import app
logging.basicConfig(level=logging.INFO)
bind = "localhost:8080"
workers = 1
zmq_url = "tcp://127.0.0.1:5555"
def post_fork(server, worker):
app.config['MODEL'], app.config['COUNTER'] = request_model(zmq_url)
在 POST_FORK Hook中，我们调用 request_model 从模型服务器中获取模型，并将模型存储在烧瓶应用程序的配置中。方法 request_model 在我的示例中定义了 client.py.py ，定义如下：
import logging
import os
from torch.multiprocessing.reductions import ForkingPickler
import zmq
def request_model(zmq_url: str):
logging.info("Connecting")
context = zmq.Context()
with context.socket(zmq.REQ) as socket:
socket.connect(zmq_url)
logging.info("Sending request")
socket.send(ForkingPickler.dumps(os.getpid()))
logging.info("Waiting for a response")
model = ForkingPickler.loads(socket.recv())
logging.info("Got response from object server")
return model
我们使用 Zeromq 用于此处的程序间通信，因为它允许我们通过名称/地址引用服务器并将服务器代码外包到其自己的应用程序中。 多仔号和多处理。 -Starting-worker/75307381“>与Gunicorn不能很好地工作。 多处理在内部使用 forkingpickler 来序列化对象，并且模块 torch.multiprocessing 以一种可以以torch数据结构为单位来改变它适当，可靠地序列化。因此，我们使用此类序列化模型将其发送到工作过程中。
该模型已加载并提供在一个完全分开的应用程序中，该应用程序完全分开并在 server.py.py.py 中定义：
from argparse import ArgumentParser
import logging
import torch
from torch.multiprocessing.reductions import ForkingPickler
import zmq
def load_model():
model = torch.nn.Linear(10000, 50000)
model.cuda()
model.share_memory()
counter = torch.zeros(1).cuda()
counter.share_memory_()
return model, counter
def share_object(obj, url):
context = zmq.Context()
socket = context.socket(zmq.REP)
socket.bind(url)
while True:
logging.info("Waiting for requests on %s", url)
message = socket.recv()
logging.info("Got a message from %d", ForkingPickler.loads(message))
socket.send(ForkingPickler.dumps(obj))
if __name__ == '__main__':
parser = ArgumentParser(description="Serve model")
parser.add_argument("--listen-address", default="tcp://127.0.0.1:5555")
args = parser.parse_args()
logging.basicConfig(level=logging.INFO)
logging.info("Loading model")
model = load_model()
share_object(model, args.listen_address)
对于此测试，我们使用大约2GB的模型，以查看GPU内存的影响 nvidia-smi 中的分配和一个小张量来验证数据实际上在过程之间共享。
我们的示例瓶应用程序以随机输入运行模型，计算请求的数量并返回两个结果：
from flask import Flask
import torch
app = Flask(__name__)
@app.route("/", methods=["POST"])
def infer():
model: torch.nn.Linear = app.config['MODEL']
counter: torch.Tensor = app.config['COUNTER']
counter[0] += 1 # not thread-safe
input_features = torch.rand(model.in_features).cuda()
return {
"result": model(input_features).sum().item(),
"counter": counter.item()
}
测试
示例可以如下运行：
$ python server.py &
INFO:root:Waiting for requests on tcp://127.0.0.1:5555
$ gunicorn -c config.py app:app
[2023-02-01 16:45:34 +0800] [24113] [INFO] Starting gunicorn 20.1.0
[2023-02-01 16:45:34 +0800] [24113] [INFO] Listening at: http://127.0.0.1:8080 (24113)
[2023-02-01 16:45:34 +0800] [24113] [INFO] Using worker: sync
[2023-02-01 16:45:34 +0800] [24186] [INFO] Booting worker with pid: 24186
INFO:root:Connecting
INFO:root:Sending request
INFO:root:Waiting for a response
INFO:root:Got response from object server
使用 nvidia-smi ，我们可以观察到，现在，两个过程正在使用GPU，其中一个分配了2GB的VRAM，而不是另一个。查询烧瓶应用程序也可以按预期工作：
$ curl -X POST localhost:8080
{"counter":1.0,"result":-23.956459045410156}
$ curl -X POST localhost:8080
{"counter":2.0,"result":-8.161510467529297}
$ curl -X POST localhost:8080
{"counter":3.0,"result":-37.823692321777344}
让我们介绍一些混乱并终止我们唯一的枪手工人：
$ kill 24186
[2023-02-01 18:02:09 +0800] [24186] [INFO] Worker exiting (pid: 24186)
[2023-02-01 18:02:09 +0800] [4196] [INFO] Booting worker with pid: 4196
INFO:root:Connecting
INFO:root:Sending request
INFO:root:Waiting for a response
INFO:root:Got response from object server
它正在正确重新启动并准备回答我们的请求。
最初的好处
，我们服务所需的VRAM的数量为（sizeof（model） + sizeof（cuda context）） * num（工人）。通过共享模型的权重，我们可以通过 sizeof（model） *（num（Workers）-1） to size> sizeof（model） + sizeof（cuda context） * num（num（num）工人）。
警告
这种方法的可靠性取决于单个模型服务器进程。如果该过程终止，新启动的工人不仅会陷入困境，而且现有工人中的模型将变得不可用，所有工人都会一次崩溃。只要服务器进程正在运行，共享张量/型号只能使用。即使重新启动模型服务器和枪支工人，也不可避免地停电也是不可避免的。因此，在生产环境中，您应确保此服务器流程保持活力。
此外，在不同过程之间共享数据可能会产生副作用。共享可变的数据时，必须使用适当的锁来避免比赛条件。
您可以创建自定义类，也可以创建另一个数组来捕获信息，
public class BoardTile {
String info;
boolean visited;
}
然后使用 boardtile [] [] [] 而不是 string [] [] [] [] []
，另外您可以创建一个单独的2D布尔值
private boolean[][] visited = new boolean[widthOfBoard, heightOfBoard];
std :: to_string（）返回 std :: String 。这就是它的作用，如果您检查C ++教科书以获取此C ++库功能的描述，这就是您将在此阅读的内容。
encString.push_back( /* something */ )
因为 venting 是 std :: vector＆lt; char＆gt; ，因此从逻辑上讲，唯一的东西可以是 push_back（），代码> char 。只有一个 char 。 C ++不允许您将整个 std :: String 传递给一个单个 char> char 参数的函数。 C ++不起作用，C ++只允许在不同类型的情况下进行某些特定的转换，这不是其中之一。
这就是为什么 encstring.push_back（to_string（runlength））; 不起作用。 [0] 操作员从返回的 std :: String 返回第一个 char 。多么幸运的巧合！您可以从中获得 char ， push_back（）期望一个 char> char 值，每个人都过着幸福的生活。
另外，重要的是要注意，不要“必须添加[0]”。如果您必须以相同的方式使用 [1] ，则可以使用字符串或字符串中的任何其他字符添加第二个字符。这解释了汇编错误。 [0] 是否是正确的解决方案，是您需要单独找出的东西。您想知道为什么如果没有 [0] >，这就是答案： to_string（）返回 std :: String 将您必须 push_back（）单一 char 值，然后使用 [0] 使其实现。无论是正确的 char ，这都是一个完全不同的问题。
使用预处理器是作弊吗？
struct A {
#define GETTER_CORE_CODE \
/* line 1 of getter code */ \
/* line 2 of getter code */ \
/* .....etc............. */ \
/* line n of getter code */
// ^ NOTE: line continuation char '\' on all lines but the last
B& get() {
GETTER_CORE_CODE
}
const B& get() const {
GETTER_CORE_CODE
}
#undef GETTER_CORE_CODE
};
它不像模板或铸件那样花哨，但它确实使您的意图（“这两个功能是相同的”）非常明确。
您需要用 with checkedthrativeContinuation 这样
func holDaten(daten: String) async throws -> String {
let ref = Database.database().reference()
let kurstxt = UserDefaults.standard.value(forKey: "aktuellerKurs") as! String
return try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<String, Error>) in
ref.child("\(kurstxt ?? "default value")/\(daten ?? "")").getData { error, snapshot in
guard error == nil else {
print(error!.localizedDescription)
continuation.resume(with: .failure(error))
return
}
let ergebnis = snapshot?.value as? String ?? "Unknown"
continuation.resume(with: .success(ergebnis))
}
}
}
因为只有标量可以传递给 获取
shift> shift> shift没有0的唯一值（否移位），仅分配匹配条件：Because only scalar is possible pass to
Series.shiftget unique values ofshiftwithout0(no shift) and assign only match condition:如何将另一列的值用作DF的参数