常連

### 実現したいこと
正解マスク画像のように予測マスクの精度を上げたい

### 発生している問題・分からないこと
![イメージ説明](https://ddjkaamml8q8x.cloudfront.net/questions/2024-09-09/8b5b4874-eecf-4f81-b76c-3f07940c9bd3.png)
右側の予測マスクを見てみると全く予測できていないことがわかります。

### エラーメッセージ
```error
エラーは特に表示されてないです
```

### 該当のソースコード

```
class UNet(nn.Module):
    def __init__(self):
        super(UNet, self).__init__()
        self.encoder = nn.Sequential(
            nn.Conv2d(1, 64, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(64, 64, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2)
        )
        self.middle = nn.Sequential(
            nn.Conv2d(64, 128, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(128, 128, kernel_size=3, padding=1),
            nn.ReLU(inplace=True)
        )
        self.decoder = nn.Sequential(
            nn.ConvTranspose2d(128, 64, kernel_size=2, stride=2),
            nn.ReLU(inplace=True),
            nn.Conv2d(64, 64, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(64, 1, kernel_size=1)
        )

    def forward(self, x):
        x1 = self.encoder(x)
        x2 = self.middle(x1)
        x = self.decoder(x2)
        return x

model = UNet()

class IoULoss(nn.Module):
    def __init__(self, weight_background=1.0, weight_foreground=5.0):
        super(IoULoss, self).__init__()
        self.weight_background = weight_background
        self.weight_foreground = weight_foreground

    def forward(self, outputs, masks):
        smooth = 1e-6
        outputs = torch.sigmoid(outputs)
        
        # 前景の計算
        intersection_foreground = (outputs * masks).sum()
        union_foreground = outputs.sum() + masks.sum() - intersection_foreground
        iou_foreground = (intersection_foreground + smooth) / (union_foreground + smooth)
        
        # 背景の計算
        outputs_inverse = 1 - outputs
        masks_inverse = 1 - masks
        intersection_background = (outputs_inverse * masks_inverse).sum()
        union_background = outputs_inverse.sum() + masks_inverse.sum() - intersection_background
        iou_background = (intersection_background + smooth) / (union_background + smooth)
        
        # 重み付けを適用
        loss = (self.weight_foreground * (1 - iou_foreground) +
                self.weight_background * (1 - iou_background))
        
        return loss


criterion = nn.BCEWithLogitsLoss()
iou_loss = IoULoss()
optimizer = optim.Adam(model.parameters(), lr=1e-4)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model.to(device)

num_epochs = 5

def check_mask_balance(mask_dir):
    mask_files = sorted([os.path.join(mask_dir, f) for f in os.listdir(mask_dir) if f.endswith('.png')])
    total_pixels = 0
    foreground_pixels = 0

    for mask_file in mask_files:
        mask = Image.open(mask_file).convert('L')
        mask_np = np.array(mask)
        total_pixels += mask_np.size
        foreground_pixels += np.sum(mask_np > 0)

    background_pixels = total_pixels - foreground_pixels
    print(f"Foreground pixels: {foreground_pixels}")
    print(f"Background pixels: {background_pixels}")

check_mask_balance(mask_dir)

train_files = set([os.path.basename(dataset.img_names[i]) for i in train_dataset.indices])
val_files = set([os.path.basename(dataset.img_names[i]) for i in val_dataset.indices])
common_files = train_files.intersection(val_files)
print(f"Number of common files: {len(common_files)}")
if len(common_files) > 0:
    print("Common files:", common_files)



def train_model():
    train_losses = []
    val_losses = []

    for epoch in range(num_epochs):
        model.train()
        running_loss = 0.0
        for batch in train_dataloader:
            images = batch['image'].to(device)
            masks = batch['mask'].to(device)

            optimizer.zero_grad()

            outputs = model(images)
            outputs = torch.sigmoid(outputs)

            bce_loss = criterion(outputs, masks)
            iou_loss_value = iou_loss(outputs, masks)
            loss = bce_loss + iou_loss_value
            loss.backward()
            optimizer.step()

            running_loss += loss.item() * images.size(0)
        epoch_loss = running_loss / len(train_dataset)
        train_losses.append(epoch_loss)
        print(f'Epoch {epoch+1}/{num_epochs}, Loss: {epoch_loss:.4f}')
        
        # 検証ステップ
        model.eval()
        val_loss = 0.0
        all_labels = []
        all_preds = []
        with torch.no_grad():
            for batch in val_dataloader:
                images = batch['image'].to(device)
                masks = batch['mask'].to(device)

                outputs = model(images)
                outputs = torch.sigmoid(outputs)

                bce_loss = criterion(outputs, masks)
                iou_loss_value = iou_loss(outputs, masks)
                loss = bce_loss + iou_loss_value
                val_loss += loss.item() * images.size(0)

                # バッチのラベルと予測を収集
                all_labels.append(masks.cpu().numpy().ravel())
                all_preds.append(outputs.cpu().numpy().ravel())
        
        val_loss = val_loss / len(val_dataset)
        val_losses.append(val_loss)
        print(f'Validation Loss: {val_loss:.4f}')

        # 予測とラベルをフラット化
        all_labels = np.concatenate(all_labels)
        all_preds = np.concatenate(all_preds)

        # ラベルをバイナリ形式に変換
        all_labels_binary = (all_labels > 0.5).astype(int)

        # 予測スコアの閾値設定
        all_preds_binary = (all_preds > 0.5).astype(int)

        # 精度計算
        accuracy = accuracy_score(all_labels_binary, all_preds_binary)
        print(f'Accuracy: {accuracy:.4f}')
    
    # 学習曲線のプロット
    plt.figure(figsize=(10, 5))
    plt.plot(train_losses, label='Training Loss')
    plt.plot(val_losses, label='Validation Loss')
    plt.xlabel('Epochs')
    plt.ylabel('Loss')
    plt.legend()
    plt.title('Training and Validation Loss over Epochs')
    plt.show()

    

    # 検証データのサンプルを表示
    display_validation_samples(val_dataloader)

def display_training_samples(dataloader, num_samples=4):
    model.eval()
    with torch.no_grad():
        for i, batch in enumerate(dataloader):
            if i >= num_samples:
                break
            images = batch['image'].to(device)
            masks = batch['mask'].to(device)

            outputs = model(images)
            outputs = torch.sigmoid(outputs)

            plt.figure(figsize=(12, 6))
            plt.subplot(1, 3, 1)
            plt.imshow(images[0].cpu().squeeze(), cmap='gray')
            plt.title('Input Image')
            plt.axis('off')

            plt.subplot(1, 3, 2)
            plt.imshow(masks[0].cpu().squeeze(), cmap='gray')
            plt.title('True Mask')
            plt.axis('off')

            plt.subplot(1, 3, 3)
            plt.imshow(outputs[0].cpu().squeeze(), cmap='gray', vmin=0, vmax=1)
            plt.title('Predicted Mask')
            plt.axis('off')

            plt.show()

# 訓練データに対する予測結果の表示
display_training_samples(train_dataloader)


def display_validation_samples(dataloader, num_samples=4):
    model.eval()
    with torch.no_grad():
        for i, batch in enumerate(dataloader):
            if i >= num_samples:
                break
            images = batch['image'].to(device)
            masks = batch['mask'].to(device)

            outputs = model(images)
            outputs = torch.sigmoid(outputs)

            plt.figure(figsize=(12, 6))
            plt.subplot(1, 3, 1)
            plt.imshow(images[0].cpu().squeeze(), cmap='gray')
            plt.title('Input Image')
            plt.axis('off')

            plt.subplot(1, 3, 2)
            plt.imshow(masks[0].cpu().squeeze(), cmap='gray')
            plt.title('True Mask')
            plt.axis('off')

            plt.subplot(1, 3, 3)
            plt.imshow(outputs[0].cpu().squeeze(), cmap='gray')
            plt.title('Predicted Mask')
            plt.axis('off')

            plt.show()

train_model()
```

### 試したこと・調べたこと
- [x] teratailやGoogle等で検索した
- [x] ソースコードを自分なりに変更した
- [ ] 知人に聞いた
- [ ] その他

##### 上記の詳細・結果
Foreground pixels: 185625
Background pixels: 27462375
Number of common files: 0
Epoch 1/5, Loss: 6.5422
Validation Loss: 6.5316
Accuracy: 0.9931
Epoch 2/5, Loss: 6.4881
Validation Loss: 6.3693
Accuracy: 0.9931
Epoch 3/5, Loss: 6.2249
Validation Loss: 6.1615
Accuracy: 0.9931
Epoch 4/5, Loss: 6.1622
Validation Loss: 6.1605
Accuracy: 0.9931
Epoch 5/5, Loss: 6.1619
Validation Loss: 6.1604
Accuracy: 0.9931

### 補足
U-Netを用いています。また生画像とマスク画像はセットにして読み込ませて学習させています。

X線画像のセグメンテーションを行いたいのですが咽頭部分が正しく抽出されず困っています。

### 実現したいこと
lastlogの出力先を/var/log/lastlogから/var/log/messagesへ変更したいです。
ただし、lastlogはデフォルトではバイナリ形式のため、テキスト形式で/var/log/messagesに出力されるようにしたいです。

### 発生している問題・分からないこと
出力先を/var/log/messagesに変更する方法はわかるのですが、テキスト形式で出力させる方法がどうしてもわかりません。



### 該当のソースコード

```
特になし
```

### 試したこと・調べたこと
- [x] teratailやGoogle等で検索した
- [ ] ソースコードを自分なりに変更した
- [ ] 知人に聞いた
- [ ] その他

##### 上記の詳細・結果
何の解決も得られませんでした。

### 補足
OSはRHEL9.2です。

Lastlogの出力先を変更したい

### 実現したいこと

モータの動作中にスイッチによってモータを停止させ、その後またモータを動かせるようにしたいです。
### 前提

ここに質問の内容を詳しく書いてください。

Arduino mega 2560を使用。モータドライバでSHEILD-MDD10を使用。外部のスイッチからの入力とエンコーダの値によりモータを制御しています。モータの動作中にスイッチによってモータを停止
させ、その後またモータを動かすことができないです。まずモータを止めるとこにも苦戦していて現在は割り込みピンを使うことで強制的に停止用の関数にとばして止めています。しかしそこからメインのループに戻ることができず、再びスイッチ入力によってモータを制御したいのですができません。

### 発生している問題・エラーメッセージ

```
エラーメッセージはなし
```

### 該当のソースコード

```Arduino言語（ほぼCとC++)
#include <Encoder.h>

#define PIN_MOTOR_DIR_1 8
#define PIN_MOTOR_PWM_1 9
#define PIN_ENCODER_1_A 22
#define PIN_ENCODER_1_B 23

#define PIN_MOTOR_DIR_2 13
#define PIN_MOTOR_PWM_2 11
#define PIN_ENCODER_2_A 24
#define PIN_ENCODER_2_B 25

#define PIN_MOTOR_DIR_3 4
#define PIN_MOTOR_PWM_3 5
#define PIN_ENCODER_3_A 26
#define PIN_ENCODER_3_B 27

#define PIN_MOTOR_DIR_4 12
#define PIN_MOTOR_PWM_4 10
#define PIN_ENCODER_4_A 28
#define PIN_ENCODER_4_B 29

#define PIN_AXIS_fr 46
#define PIN_AXIS_fl 47
#define PIN_AXIS_br 48
#define PIN_AXIS_bl 49
#define PIN_AXIS_lr 50
#define PIN_AXIS_ll 51
#define PIN_AXIS_rr 52
#define PIN_AXIS_rl 53

#define PIN_LIM 2

//距離設定
int fdistance = -7000;  //-7000
int updistance = 4000;   //4000

int pwm1 = 150;
int pwm2 = 150;
int pwm3 = 150;
int pwm4 = 150;

Encoder encoder1(PIN_ENCODER_1_A, PIN_ENCODER_1_B);
Encoder encoder2(PIN_ENCODER_2_A, PIN_ENCODER_2_B);
Encoder encoder3(PIN_ENCODER_3_A, PIN_ENCODER_3_B);
Encoder encoder4(PIN_ENCODER_4_A, PIN_ENCODER_4_B);

bool forward_moved = false;

void setup() {


  //励磁音を消す

  TCCR2B = (TCCR2B & 0b11111000) | 0x01; //9,10
  TCCR1B = (TCCR1B & 0b11111000) | 0x01; //11,12
  TCCR3B = (TCCR3B & 0b11111000) | 0x01; //2,3,5

  pinMode(PIN_MOTOR_DIR_1, OUTPUT);
  pinMode(PIN_MOTOR_PWM_1, OUTPUT);
  pinMode(PIN_MOTOR_DIR_2, OUTPUT);
  pinMode(PIN_MOTOR_PWM_2, OUTPUT);
  pinMode(PIN_MOTOR_DIR_3, OUTPUT);
  pinMode(PIN_MOTOR_PWM_3, OUTPUT);
  pinMode(PIN_MOTOR_DIR_4, OUTPUT);
  pinMode(PIN_MOTOR_PWM_4, OUTPUT);
  pinMode(PIN_AXIS_fl, INPUT_PULLUP);
  pinMode(PIN_AXIS_fr, INPUT_PULLUP);
  pinMode(PIN_AXIS_bl, INPUT_PULLUP);
  pinMode(PIN_AXIS_br, INPUT_PULLUP);
  pinMode(PIN_AXIS_ll, INPUT_PULLUP);
  pinMode(PIN_AXIS_lr, INPUT_PULLUP);
  pinMode(PIN_AXIS_rl, INPUT_PULLUP);
  pinMode(PIN_AXIS_rr, INPUT_PULLUP);
  pinMode(PIN_LIM, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(2),stopmotor,FALLING);

  Serial.begin(9600);
}

void loop() {
  int axis_fl_state = digitalRead(PIN_AXIS_fl);
  int axis_fr_state = digitalRead(PIN_AXIS_fr);
  int axis_bl_state = digitalRead(PIN_AXIS_bl);
  int axis_br_state = digitalRead(PIN_AXIS_br);
  int axis_ll_state = digitalRead(PIN_AXIS_ll);
  int axis_lr_state = digitalRead(PIN_AXIS_lr);
  int axis_rl_state = digitalRead(PIN_AXIS_rl);
  int axis_rr_state = digitalRead(PIN_AXIS_rr);

  int lim_state = digitalRead(PIN_LIM);

  Serial.print("Encoder 1: ");
  Serial.print(encoder1.read());
  Serial.print("  Encoder 2: ");
  Serial.print(encoder2.read());
  Serial.print("  Encoder 3: ");
  Serial.print(encoder3.read());
  Serial.print("  Encoder 4: ");
  Serial.println(encoder4.read());

  if (axis_fl_state == LOW && axis_fr_state == LOW) {

    digitalWrite(PIN_MOTOR_DIR_3, HIGH);
    analogWrite(PIN_MOTOR_PWM_3, pwm3);
    digitalWrite(PIN_MOTOR_DIR_4, HIGH);
    analogWrite(PIN_MOTOR_PWM_4, pwm4);
    }
    while (encoder3.read() > fdistance) {
      //待機
    }
    analogWrite(PIN_MOTOR_PWM_3, 0);
    analogWrite(PIN_MOTOR_PWM_4, 0);
    delay(1000);


    digitalWrite(PIN_MOTOR_DIR_1, LOW);
    analogWrite(PIN_MOTOR_PWM_1, pwm1);
    digitalWrite(PIN_MOTOR_DIR_2, LOW);
    analogWrite(PIN_MOTOR_PWM_2, pwm2);
    digitalWrite(PIN_MOTOR_DIR_3, LOW);
    analogWrite(PIN_MOTOR_PWM_3, pwm3);
    digitalWrite(PIN_MOTOR_DIR_4, LOW);
    analogWrite(PIN_MOTOR_PWM_4, pwm4);

    // モータ1が-4000になるまで待機
    while (encoder1.read() < updistance) {
      // 待機
    }
    analogWrite(PIN_MOTOR_PWM_1, 0);
    analogWrite(PIN_MOTOR_PWM_2, 0);


    while (encoder3.read() < -4000) {
      // 待機
    }
    analogWrite(PIN_MOTOR_PWM_3, 0);
    analogWrite(PIN_MOTOR_PWM_4, 0);
    delay(100);


    //----------------------------------------------------
  } else if (axis_bl_state == LOW && axis_br_state == LOW) {
    // モーター1とモーター3を後退方向に動かす
    digitalWrite(PIN_MOTOR_DIR_1, HIGH);
    analogWrite(PIN_MOTOR_PWM_1, pwm1);
    digitalWrite(PIN_MOTOR_DIR_2, HIGH);
    analogWrite(PIN_MOTOR_PWM_2, pwm2);
    digitalWrite(PIN_MOTOR_DIR_3, HIGH);
    analogWrite(PIN_MOTOR_PWM_3, pwm3);
    digitalWrite(PIN_MOTOR_DIR_4, HIGH);
    analogWrite(PIN_MOTOR_PWM_4, pwm4);

    // モーター1が0に到達するまで待機
    while (encoder1.read() > 0) {
      // 待機
    }
    analogWrite(PIN_MOTOR_PWM_1, 0);
    analogWrite(PIN_MOTOR_PWM_2, 0);

    // モーター3が7000に到達するまで待機
    while (encoder3.read() > fdistance) {
      // 待機
    }
    analogWrite(PIN_MOTOR_PWM_3, 0);
    analogWrite(PIN_MOTOR_PWM_4, 0);
    delay(1000);

    // モータ3を指定の位置まで動かす
    digitalWrite(PIN_MOTOR_DIR_3, LOW);
    analogWrite(PIN_MOTOR_PWM_3, pwm3);
    digitalWrite(PIN_MOTOR_DIR_4, LOW);
    analogWrite(PIN_MOTOR_PWM_4, pwm4);
    while (encoder3.read() < 0) {
      // 待機
    }
    analogWrite(PIN_MOTOR_PWM_3, 0);
    analogWrite(PIN_MOTOR_PWM_4, 0);
    delay(1000);
    //-------------------------------------------------------

  }
}

void stopmotor(){
  analogWrite(PIN_MOTOR_PWM_1, 0);
  analogWrite(PIN_MOTOR_PWM_2, 0);
  analogWrite(PIN_MOTOR_PWM_3, 0);
  analogWrite(PIN_MOTOR_PWM_4, 0);

  attachInterrupt(digitalPinToInterrupt(2), stopmotor, FALLING);
}
```

### 試したこと

ここに問題に対して試したことを記載してください。

### 補足情報（FW/ツールのバージョンなど）

ここにより詳細な情報を記載してください。


Ardinoでモータを動かすとき割り込みを使い外部入力によってモータを停止したあと、またメインのループにもどることができない

### 実現したいこと

tang nano 20k上で[linux on litex vexriscv](https://github.com/litex-hub/linux-on-litex-vexriscv)を動作させ、自作のcプログラムを実行したいです。
そのためにボード上で満足に動作できるサイズのLinux Imageなどをbuildrootを使用して作成したいです。

### 前提

tang nano 20kボードの制作会社が用意してくれた起動に必要なファイルは[TangNano-20K-exampleリポジトリ](https://github.com/sipeed/TangNano-20K-example)にまとめられているのですが、このlinux imageなどは本当に最低限のlinux(2MBほど)でsd cardの読み取りなどが全くできません。
動作させたい実行ファイルなどを持ち込めず不便なので、linux imageを自作します。
[buildrootを用いた作成方法](https://github.com/litex-hub/linux-on-litex-vexriscv#-generating-the-linux-binaries-optional)があるのでこれに従ってImageを作成したところ7.7MBほどのものが出来上がりました。
いざそれを使用して起動を試みるとボードのramが8MiBまでしかないらしく、その他もろもろのファイルも含めて場所が足りないので起動しませんでした。
悩んでいると[この記事](https://www.luffca.com/ja/2022/10/linux-tang-primer/)に出会いました。
記事ではtang nano 20kより前の性能が劣っているtang primerというボードで[linux on litex vexriscv](https://github.com/litex-hub/linux-on-litex-vexriscv)cpuを用いたlinux起動に成功していました。
そして`Tang PrimerのSRAMは約130KiBだけなので、8MiBのSDRAMのサポート追加とLinuxカーネルのサイズ縮小が必須でした。`とのことだったので、やはりlinux imageを小さくする必要があると思いました。
buildrootのディレクトリで`make menuconfig`を開きますがいじるべき箇所がわからず詰まってしまいました。
なにかご存じの方がいましたら回答いただけると助かります。
よろしくお願いします。

### 発生している問題・エラーメッセージ

buildrootでどのようにサイズの小さいlinux imageを作れるのかわからない。


### 補足情報（FW/ツールのバージョンなど）

https://buildroot.org/

buildrootで小さいLinux imageを作成したい

### 実現したいこと
ラズベリーパイのカメラ映像のタイトルバーを非表示にしたいです。

### 前提
python初心者です。
Thonnyでカメラの映像を出力したのですが、タイトルバーが邪魔です。
消す方法はありませんか？

このコードはカメラ映像を２つ出力できるようになってます。

### 該当のソースコード
```
import numpy as np
import cv2

video_capture_0 = cv2.VideoCapture(0)
video_capture_0.set(cv2.CAP_PROP_FPS, 10)

video_capture_1 = cv2.VideoCapture(2)
video_capture_1.set(cv2.CAP_PROP_FPS, 10)

while True:
    # Capture frame-by-frame
    ret0, frame0 = video_capture_0.read()
    ret1, frame1 = video_capture_1.read()
    frame0=cv2.resize(frame0,(720,480))
    frame1=cv2.resize(frame1,(720,480))

    im_v1 = cv2.hconcat([frame0, frame1])
    
    cv2.imshow('concat', im_v1)

    if cv2.waitKey(1) & 0xFF == ord('q'):
        cv2.imwrite('photo.jpg', frame1)
        break

# When everything is done, release the capture
video_capture_0.release()
video_capture_1.release()

cv2.destroyAllWindows()
```


