问题[machine-learning](coding)

我是 Rust 的新手，我正在研究使用Burn移植一些 Python/Torch 代码用于新的统计参数方法。

第一步：我想生成一个 (10, 1) 张量，其随机值来自具有已知参数的柯西分布。Burn 中的分布非常有限，因此我使用statrs。通过使用statrs，我可以得到Vec<f64>，然后我可以将其包装到TensorDataBurn 中的 中，从而生成Tensor。

我添加了一些类型签名，但 Burn 有Float而不是特定的f64，我对此有点困惑。事实上，只是为了调试目的，我想从 Burn 张量中提取数据作为Vec<f64>来查看它（我应该从中看到相同的值vec: Vec<f64>），但我得到了运行时类型不兼容。

use rand::prelude::Distribution;
use statrs::distribution::Cauchy;
use rand_chacha::ChaCha8Rng;
use rand_core::SeedableRng;
use burn::tensor::{Tensor, TensorData, Float};
use burn::backend::Wgpu;

type Backend = Wgpu;

fn main() {
    // some global refs
    let device = Default::default();
    let mut rng: ChaCha8Rng = ChaCha8Rng::seed_from_u64(2);

    // create random vec using statrs, store in a Vec<f64>
    let dist: Cauchy = Cauchy::new(5.0, 2.0).unwrap();
    let vec: Vec<f64> = dist.sample_iter(&mut rng).take(10).collect();

    // wrap this into a Burn tensor
    let td: TensorData = TensorData::new(vec, [10, 1]);
    let tensor: Tensor<Backend, 2, Float> = Tensor::<Backend, 2, Float>::from_data(td, &device);

    print!("{:?}\n", tensor.to_data().to_vec::<f64>().unwrap());
}

当在上面运行时，我得到

thread 'main' panicked at src/main.rs:23:55:
called `Result::unwrap()` on an `Err` value: TypeMismatch("Invalid target element type 
(expected F32, got F64)")

使用to_vec::<f32>有效，但我希望 Burn 张量具有 f64 值（torch 有这个），因为错误似乎意味着我在某个时候失去了精度——不太好。

是否可以存储f64在 Burn 张量中？

我使用 MNIST 数据集创建了一个 CNN 模型。我想预测图像中存在的数字序列。该技术涉及分割每张图像并将其输入模型，但我在从图像中分割数字时遇到了困难，因为存在两种不同类型的图像。我需要一种强大的技术，可以消除图像中存在的所有噪音和阴影，并分别分割每个数字。我也在这里分享这些图片。我正在寻找强大的技术和代码。

我正在尝试这个代码和技术，但它对所附的图像不起作用

def segment_and_display_digits(image_path):# Read imageimg = cv2.imread(image_path)gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# Get image dimensions
height, width = gray.shape
total_area = height * width

# Apply adaptive thresholding
thresh = cv2.adaptiveThreshold(
    gray,
    255,
    cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
    cv2.THRESH_BINARY_INV,
    21,  # Block size
    10   # C constant
)

# Find contours
contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

# Filter contours based on area
valid_contours = []
min_area = total_area * 0.001  # Minimum 0.1% of image area
max_area = total_area * 0.5    # Maximum 50% of image area

for cnt in contours:
    area = cv2.contourArea(cnt)
    if min_area < area < max_area:
        x, y, w, h = cv2.boundingRect(cnt)
        aspect_ratio = w / float(h)
        # Check if aspect ratio is reasonable for a digit (not too wide or tall)
        if 0.2 < aspect_ratio < 2:
            valid_contours.append(cnt)

# Sort contours from left to right
valid_contours = sorted(valid_contours, key=lambda x: cv2.boundingRect(x)[0])

# Extract and display digits
digits = []
padding = int(min(height, width) * 0.02)  # Adaptive padding based on image size

for cnt in valid_contours:
    x, y, w, h = cv2.boundingRect(cnt)
    # Add padding while keeping within image bounds
    x1 = max(0, x - padding)
    y1 = max(0, y - padding)
    x2 = min(width, x + w + padding)
    y2 = min(height, y + h + padding)
    digit = img[y1:y2, x1:x2]
    digits.append(digit)

# Display results
if digits:
    # Create visualization of original image with detected digits
    img_with_boxes = img.copy()
    for cnt in valid_contours:
        x, y, w, h = cv2.boundingRect(cnt)
        cv2.rectangle(img_with_boxes, (x, y), (x+w, y+h), (0, 255, 0), 2)
    
    # Plot original image with boxes and segmented digits
    plt.figure(figsize=(15, 5))
    
    # Original image with boxes
    plt.subplot(2, 1, 1)
    plt.imshow(cv2.cvtColor(img_with_boxes, cv2.COLOR_BGR2RGB))
    plt.title('Detected Digits')
    plt.axis('off')
    
    # Segmented digits
    plt.subplot(2, 1, 2)
    for i, digit in enumerate(digits):
        plt.subplot(2, len(digits), len(digits) + i + 1)
        plt.imshow(cv2.cvtColor(digit, cv2.COLOR_BGR2RGB))
        plt.axis('off')
        plt.title(f'Digit {i+1}')
    
    plt.tight_layout()
    plt.show()
else:
    print("No digits found in the image")

我想在本地使用 llama-index 与 ollama 和 llama3:8b 来索引 utf-8 json 文件。我没有GPU。我使用 uncharted 将文档转换为 json。现在，如果无法在没有 GPU 的情况下在本地使用 llama-index，我想使用拥抱脸部推理 API。但我不确定它是否免费。有人能建议一种方法吗？

这是我的Python代码：

    从 llama_index.core 导入文档、SimpleDirectoryReader、VectorStoreIndex
    从 llama_index.llms.ollama 导入 Ollama
    导入 json
    从 llama_index.core 导入设置
    
    
    # 将 JSON 文档转换为 LlamaIndex Document 对象
    open('data/UBER_2019.json', 'r',encoding='utf-8') 作为 f：
        json_doc = json.load(f)
    文档 = [json_doc 中的文档的文档(text=str(doc))]
    
    # 使用本地 LLM 初始化 Ollama
    ollama_llm = Ollama(model="llama3:8b")
    设置.llm = ollama_llm
    
    # 使用本地LLM创建索引
    索引 = VectorStoreIndex.from_documents(documents)#, llm=ollama_llm)

但我不断收到没有 OPENAI 密钥的错误。我想使用 llama2 这样就不需要 OPENAI 密钥

谁能建议我做错了什么？我还可以使用 Huggingfaceinference API 免费对本地 json 文件进行索引吗？

我正在开发一个机器学习项目，我的数据集包含 218 个国家（从 1960 年到 2022 年）的社会、人口和经济方面的变量。目标变量是一个二元变量（是或否），表示该国家/地区是否在某一年至少发生过一次政变企图。我的问题是：多层次数据的最佳分类模型是什么？

通过咨询不同的来源，我写下了这些模型（没有特定的顺序）：

• 随机森林
• XGBoost
• 物流分类
• 决策树

他们是错误的吗？还有更多我不知道的型号吗？如果没有，您知道我可以使用哪些资源在 R 中实现这些模型吗？

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

input = torch.tensor([1.,2.], requires_grad=True)
sigmoid = nn.Sigmoid()

interm = sigmoid(input)

optimizer = optim.SGD([input], lr=1, momentum=0.9)

for epoch in range(5):
    optimizer.zero_grad()
    loss = torch.linalg.vector_norm(interm - torch.tensor([2.,2.]))
    print(epoch, loss, input, interm)

    loss.backward(retain_graph=True)
    optimizer.step()
    print(interm.grad)

因此，我创建了这个简化的示例，其中输入进入 sigmoid 作为中间激活函数。

我试图找到导致interm = [2.,2.]的输入

但梯度没有通过。有人知道为什么吗？

我使用 pytorch 和 keras 实现了一个简单的线性模型，以学习每个库的基础知识。我建立了一个用于线性回归的一层模型。两种模型似乎都有效，并且损失正在减少，但是当 pytorch 模型达到最小值时，损失会反弹，而在 keras 中，损失是稳定的。我使用的数据是合成的并经过线性测试。

这是keras模型

IceCream = pd.read_csv("IceCreamData.csv")
x_values = IceCream[["Temperature"]]
y_values = IceCream["Revenue"]
x_train, x_test, y_train, y_test = train_test_split(x_values, y_values, test_size=0.25)

model = tf.keras.Sequential()
model.add(tf.keras.layers.Dense(units=1,
                                kernel_initializer=tf.keras.initializers.RandomNormal(stddev=0.01),
                                bias_initializer=tf.keras.initializers.Zeros())
          )
model.compile(optimizer=tf.keras.optimizers.Adam(0.01, epsilon=1e-07), loss='mean_squared_error')
model.fit(x_train, y_train, epochs=25, batch_size=1)

给出以下训练数据：

375/375 [==============================] - 0s 617us/step - loss: 261208.2969
Epoch 2/25
375/375 [==============================] - 0s 568us/step - loss: 192060.6094
Epoch 3/25
375/375 [==============================] - 0s 577us/step - loss: 137438.0000
(...)
Epoch 20/25
375/375 [==============================] - 0s 536us/step - loss: 667.3316
Epoch 21/25
375/375 [==============================] - 0s 535us/step - loss: 665.7455
Epoch 22/25
375/375 [==============================] - 0s 535us/step - loss: 666.8908
Epoch 23/25
375/375 [==============================] - 0s 577us/step - loss: 665.0857
Epoch 24/25
375/375 [==============================] - 0s 536us/step - loss: 662.0533
Epoch 25/25
375/375 [==============================] - 0s 534us/step - loss: 661.3047

这是pytorch模型：

class RegressionDataset(Dataset):
    def __init__(self, x, y):
        super().__init__()
        self.x = torch.from_numpy(x.astype("float32"))
        self.y = torch.from_numpy(y.astype("float32"))

    def __len__(self):
        return len(self.x)

    def __getitem__(self, index):
        return self.x[index], self.y[index].unsqueeze(0)


class LinearRegressionModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(1, 1)
        self.loss_function = nn.MSELoss()
        self.optimizer_function = torch.optim.Adam(self.parameters(), lr=0.01, eps=1e-07)
        torch.nn.init.normal_(self.linear.weight, mean=0.0, std=1.0)

    def forward(self, inputs):
        return self.linear(inputs)

    def backward(self, train_loader, epoch, num_epochs):
        self.train()

        for x_values, y_values in train_loader:
            prediction = self.linear(x_values)
            loss = self.loss_function(prediction, y_values)
            loss.backward()
            self.optimizer_function.step()
            self.optimizer_function.zero_grad()

        print(f"Epoch [{epoch + 1:03}/{num_epochs:3}] | Train Loss: {loss.item():.4f}")

    def validate(self, val_loader):
        self.eval()

        with torch.no_grad():
            for inputs, targets in val_loader:
                outputs = self.linear(inputs)
                loss = self.loss_function(outputs, targets)

        print(f'Validation Loss: {loss.item():.4f}')


data = pd.read_csv("./IceCreamData.csv", delimiter=",")
x_values = data[["Temperature"]].to_numpy()
y_values = data["Revenue"].to_numpy()

dataset = RegressionDataset(x_values, y_values)
train_dataset, test_dataset = random_split(dataset, lengths=[0.75, 0.25])
train_loader = DataLoader(dataset=train_dataset, batch_size=1, shuffle=True)
test_loader = DataLoader(dataset=test_dataset, batch_size=1, shuffle=True)

model = LinearRegressionModel()
num_epochs = 25
for epoch in range(num_epochs):
    model.backward(train_loader, epoch, num_epochs)
    model.validate(test_loader)

给出以下训练结果：

Epoch [001/ 25] | Train Loss: 248788.2500
Validation Loss: 257732.9062
Epoch [002/ 25] | Train Loss: 96519.7422
Validation Loss: 110466.8281
Epoch [003/ 25] | Train Loss: 76869.0547
Validation Loss: 178772.9375
(...)
Epoch [020/ 25] | Train Loss: 679.7694
Validation Loss: 1674.3351
Epoch [021/ 25] | Train Loss: 2065.5454
Validation Loss: 1177.6052
Epoch [022/ 25] | Train Loss: 269.6078
Validation Loss: 595.9854
Epoch [023/ 25] | Train Loss: 115.4116
Validation Loss: 0.1172
Epoch [024/ 25] | Train Loss: 2134.9248
Validation Loss: 9816.9375
Epoch [025/ 25] | Train Loss: 37.1115
Validation Loss: 2869.8569

首先，我认为它是由不同的权重初始值导致的，因此我实现了带有标准差的初始化。

我还使用不同的学习率值进行了测试，但也没有更好的结果。根据文档，其他参数（如动量、贝塔值等）应该是相同的。只有 epsilon 不同，我在代码中进行了调整。

为什么pytorch模型的loss达到最小值时会上下跳动，而keras模型loss却稳定？