Software Engineer

[Solidworks] Tap Thread 나사산 표시

J-sean — Sun, 26 Jul 2026 23:10:45 +0900

솔리드웍스에서 주석 나사산을 표시해 보자. 실제 모델을 깎아서 구현하는 나사산이 아닌 그림으로만 표시하는 나사산이다.

화면에 나사산이 표시되도록 Document Properties - Detailing에서 Cosmetic threads와 Shaded cosmetic threads를 선택한다.

Cosmetic threads는 1번 화살표가 가리키는 실선을 표시하고 Shaded cosmetic threads는 2번 화살표가 가리키는 음영 나사산을 표시한다.

Hole Wizard로 나사산을 만들 땐 Hole Type에 있는 두 가지 탭 중 하나를 선택해야 Options에 나사산 관련 옵션이 표시된다.

Insert - Annotations - Cosmetic Thread...에서도 나사산을 만들 수 있다.

만약 나사산이 표시되지 않는다면 View Top Level Annotations가 선택되어 있는지 확인하자.

[C#] Asynchronously Write DateTime and Value Text File 시간, 값 데이터 텍스트 파일 비동기 쓰기

J-sean — Mon, 20 Jul 2026 16:44:28 +0900

시간과 임의의 값을 비동기적으로 텍스트 파일로 저장하고 확인해 보자.

namespace DateTimeValue
{
    public partial class Form1 : Form
    {
        private readonly string filePath = "output.txt";        
        readonly Random random = new Random();

        public Form1()
        {
            InitializeComponent();

            button1.Click += Button1_Click;
            button2.Click += Button2_Click;
        }

        // 비동기적으로 파일에 현재 시간과 랜덤 값을 기록하는 버튼 클릭 이벤트 핸들러
        // 비동기 메서드는 Task를 반환하는게 좋지만 이벤트 핸들러는 void를 반환해야 하므로 어쩔 수 없이 async void를 사용
        private async void Button1_Click(object? sender, EventArgs e)
        {
            try
            {
                // 버튼 클릭 시 버튼을 비활성화하여 중복 클릭 방지
                button1.Enabled = false; // 버튼 비활성화

                FileStream fileStream = new FileStream (
                    filePath,
                    FileMode.Append,  // 파일이 없으면 새로 생성하고, 있으면 이어쓰기
                    FileAccess.Write, // 쓰기 전용
                    FileShare.Read); // 다른 프로세스가 파일을 읽을 수 있도록 허용, 내가 쓰는 동안 다른 프로세스는 읽기 가능
                
                using (StreamWriter writer = new StreamWriter(fileStream, System.Text.Encoding.UTF8))
                {
                    for (int i = 0; i < 5; i++)
                    {
                        await writer.WriteLineAsync(DateTime.Now.ToString("yyyyMMdd-HHmmss") + " " + random.Next());
                        // 비동기적으로 파일에 기록
                        await writer.FlushAsync();
                        // 비동기적으로 버퍼를 파일에 기록

                        // 비동기적으로 1초 대기
                        await Task.Delay(1000);
                    }
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show($"오류 발생: {ex.Message}");
            }
            finally
            {
                button1.Enabled = true; // 버튼 활성화
            }
        }

        private async void Button2_Click(object? sender, EventArgs e)
        {
            listBox1.Items.Clear(); // 기존 항목 제거
            try
            {
                FileStream fileStream = new FileStream(
                    filePath,
                    FileMode.Open, // 파일이 없으면 예외 발생
                    FileAccess.Read, // 읽기 전용
                    FileShare.ReadWrite); // 다른 프로세스가 파일을 읽을 수 있도록 허용, 내가 읽는 동안 다른 프로세스도 읽기/쓰기 가능

                using (StreamReader reader = new StreamReader(fileStream, System.Text.Encoding.UTF8))
                {
                    string? line;
                    while ((line = await reader.ReadLineAsync()) != null)
                    {
                        //listBox1.Items.Add(line);

                        // 공백 문자를 기준으로 분리
                        string[] parts = line.Split(' ');
                        if (parts.Length == 2)
                        {
                            listBox1.Items.Add("시간: " + DateTime.ParseExact(parts[0], "yyyyMMdd-HHmmss", null) + "\t값: " + parts[1]);
                            // ParseExact() 세번째 인자를 null로 주면 현재 문화권의 형식으로 해석, InvariantCulture를 주면 문화권에 상관없이 해석
                        }
                        else
                        {
                            listBox1.Items.Add("Error");
                        }
                    }
                }
            }
            catch (FileNotFoundException)
            {
                MessageBox.Show($"{filePath} 파일이 존재하지 않습니다.");
            }
            catch (Exception ex)
            {
                MessageBox.Show($"오류 발생: {ex.Message}");
            }            
        }
    }
}

Record 버튼을 클릭해 로그 파일을 생성하고 Show 버튼을 클릭해 원하는 로그 파일을 선택하면 리스트 박스에 로그가 표시된다.

그래프를 추가해 보자.

Graph 버튼을 추가한다.

using System.Diagnostics;

namespace DateTimeValue
{
    public partial class Form1 : Form
    {
        internal string filePath = string.Empty; // Form2에서 접근할 수 있도록 internal로 선언
        readonly Random random = new Random();

        public Form1()
        {
            InitializeComponent();

            button1.Click += Button1_Click;
            button2.Click += Button2_Click;
            button3.Click += Button3_Click;
        }

        // 비동기적으로 파일에 현재 시간과 랜덤 값을 기록하는 버튼 클릭 이벤트 핸들러
        // 비동기 메서드는 Task를 반환하는게 좋지만 이벤트 핸들러는 void를 반환해야 하므로 어쩔 수 없이 async void를 사용
        private async void Button1_Click(object? sender, EventArgs e)
        {
            try
            {
                // 버튼 클릭 시 버튼을 비활성화하여 중복 클릭 방지
                button1.Enabled = false; // 버튼 비활성화

                int count = 120; // 테스트를 위해 120회(120초)만 기록
                string mm = string.Empty;
                string now = string.Empty;
                bool needNewFile = false; // 새로운 파일 생성 여부를 나타내는 플래그

                while (true)
                {
                    filePath = DateTime.Now.ToString("yyyyMMdd-HHmmss") + ".txt"; // 파일 이름을 현재 시간으로 설정                    
                    mm = Path.GetFileName(filePath).Substring(11, 2); // 파일 이름에서 '분'만 추출

                    FileStream fileStream = new FileStream(
                        filePath,
                        FileMode.Append,  // 파일이 없으면 새로 생성하고, 있으면 이어쓰기
                        FileAccess.Write, // 쓰기 전용
                        FileShare.Read); // 다른 프로세스가 파일을 읽을 수 있도록 허용, 내가 쓰는 동안 다른 프로세스는 읽기 가능

                    using (StreamWriter writer = new StreamWriter(fileStream, System.Text.Encoding.UTF8))
                    {
                        while (true)
                        {
                            now = DateTime.Now.ToString("yyyyMMdd-HHmmss");
                            if (now.Substring(11, 2) != mm) // 현재 '분'이 파일 이름의 '분'과 다르면
                            {
                                needNewFile = true;
                                break; // 루프 종료하여 새로운 파일 생성
                            }

                            await writer.WriteLineAsync(now + " " + random.Next(1, 11)); // 1부터 10까지의 랜덤 값을 기록
                            // 비동기적으로 파일에 기록
                            await writer.FlushAsync();
                            // 비동기적으로 버퍼를 파일에 기록

                            await Task.Delay(1000);
                            // 비동기적으로 1초 대기

                            count--;
                            if (count < 0)
                                break; // 기록 횟수가 0이 되면 루프 종료
                            Debug.WriteLine($"남은 기록 횟수: {count}");
                        }
                    }

                    // needNewFile보다 count를 먼저 확인하여 무한 루프를 방지
                    if (count < 0)
                    {
                        break; // 무한 루프 종료
                    }
                    if (needNewFile)
                    {
                        needNewFile = false; // 새로운 파일 생성 여부 플래그 초기화
                        continue; // 새로운 파일 생성 루프 시작
                    }
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show($"오류 발생: {ex.Message}");
            }
            finally
            {
                button1.Enabled = true; // 버튼 활성화
            }
        }

        private async void Button2_Click(object? sender, EventArgs e)
        {
            FileDialog fileDialog = new OpenFileDialog();
            fileDialog.InitialDirectory = Application.StartupPath; // 실행 파일이 있는 폴더 경로
            fileDialog.Filter = "텍스트 파일 (*.txt)|*.txt|모든 파일 (*.*)|*.*";
            fileDialog.Title = "파일 선택";
            fileDialog.DefaultExt = "txt";

            if (fileDialog.ShowDialog() == DialogResult.OK)
                filePath = fileDialog.FileName;
            else
                return; // 파일 선택 취소 시 종료

            listBox1.Items.Clear(); // 기존 항목 제거

            try
            {
                FileStream fileStream = new FileStream(
                    filePath,
                    FileMode.Open, // 파일이 없으면 예외 발생
                    FileAccess.Read, // 읽기 전용
                    FileShare.ReadWrite); // 다른 프로세스가 파일을 읽을 수 있도록 허용, 내가 읽는 동안 다른 프로세스도 읽기/쓰기 가능

                using (StreamReader reader = new StreamReader(fileStream, System.Text.Encoding.UTF8))
                {
                    string? line;
                    while ((line = await reader.ReadLineAsync()) != null)
                    {
                        //listBox1.Items.Add(line);

                        // 공백 문자를 기준으로 문자열 분리
                        string[] parts = line.Split(' ');
                        if (parts.Length == 2)
                        {
                            listBox1.Items.Add("시간: " + DateTime.ParseExact(parts[0], "yyyyMMdd-HHmmss", null) + "\t값: " + parts[1]);
                            // ParseExact() 세번째 인자를 null로 주면 현재 문화권의 형식으로 해석, InvariantCulture를 주면 문화권에 상관없이 해석
                        }
                        else
                        {
                            listBox1.Items.Add("Error");
                        }
                    }
                }
            }
            catch (FileNotFoundException)
            {
                MessageBox.Show($"{filePath} 파일이 존재하지 않습니다.");
            }
            catch (Exception ex)
            {
                MessageBox.Show($"오류 발생: {ex.Message}");
            }
        }

        private void Button3_Click(object? sender, EventArgs e)
        {
            Form2 dlg = new Form2();
            dlg.Owner = this; // Form1을 Form2의 소유자로 설정
            // 아니면 아래 if문에서 dlg.ShowDialog(this) 명령으로 Form1을 Form2의 소유자로 설정할 수도 있다
            if (dlg.ShowDialog() == DialogResult.OK)
                ; // Form2에서 OK 버튼을 클릭하면 처리할 내용 작성

            dlg.Close();
            dlg.Dispose();
        }
    }
}

Visual Studio - Project - Add Form(Windows Forms)... 을 클릭하고 Form을 하나 추가한다.

버튼을 하나 배치한다.

NuGet Package Manager - LiveChartsCore.SkiaSharpView.WinForms 를 설치한다.

using LiveChartsCore;
using LiveChartsCore.Defaults;
using LiveChartsCore.SkiaSharpView;
using LiveChartsCore.SkiaSharpView.WinForms;

using System.Collections.ObjectModel;
using System.Diagnostics;

namespace DateTimeValue
{
    public partial class Form2 : Form
    {
        private readonly ObservableCollection<DateTimePoint> values = new ObservableCollection<DateTimePoint>();

        public Form2()
        {
            InitializeComponent();

            button1.DialogResult = DialogResult.OK; // 버튼 클릭 시 DialogResult를 OK로 설정
            this.Load += Form2_Load; // Form2 로드 이벤트에 핸들러 추가                        
        }

        private async void Form2_Load(object? sender, EventArgs e)
        {
            Form1? parent = Owner as Form1; // Form1 인스턴스를 가져옴

            if (parent != null)
                if (string.IsNullOrEmpty(parent.filePath))
                {
                    // 파일 경로가 설정되지 않은 경우, 메시지 박스를 표시하고 종료
                    MessageBox.Show("파일 경로가 설정되지 않았습니다.");
                    // Form2 종료
                    Close();
                }
                else
                {
                    try
                    {
                        FileStream fileStream = new FileStream(
                            parent.filePath,
                            FileMode.Open, // 파일이 없으면 예외 발생
                            FileAccess.Read, // 읽기 전용
                            FileShare.ReadWrite); // 다른 프로세스가 파일을 읽을 수 있도록 허용, 내가 읽는 동안 다른 프로세스도 읽기/쓰기 가능

                        using (StreamReader reader = new StreamReader(fileStream, System.Text.Encoding.UTF8))
                        {
                            string? line;
                            while ((line = await reader.ReadLineAsync()) != null)
                            {
                                //listBox1.Items.Add(line);

                                // 공백 문자를 기준으로 분리
                                string[] parts = line.Split(' ');
                                if (parts.Length == 2)
                                {
                                    values.Add(new DateTimePoint(DateTime.ParseExact(parts[0], "yyyyMMdd-HHmmss", null), double.Parse(parts[1])));
                                    // ParseExact() 세번째 인자를 null로 주면 현재 문화권의 형식으로 해석, InvariantCulture를 주면 문화권에 상관없이 해석
                                }
                                else
                                {
                                    Debug.WriteLine($"잘못된 형식의 데이터: {line}");
                                }
                            }

                            ISeries[] series = new ISeries[]
                            {
                                new LineSeries<DateTimePoint>
                                {
                                    Values = values,
                                    Fill = null
                                }
                            };

                            CartesianChart cartesianChart = new CartesianChart
                            {
                                Series = series,
                                ZoomMode = LiveChartsCore.Measure.ZoomAndPanMode.X,
                                Location = new System.Drawing.Point(0, 0),
                                Size = new System.Drawing.Size(800, 300),
                                Anchor = AnchorStyles.Left | AnchorStyles.Right | AnchorStyles.Top | AnchorStyles.Bottom,
                                // X축 설정
                                XAxes = new Axis[]
                                {
                                    //new Axis
                                    //{
                                    //    Labeler = value => new DateTime((long)value).ToString("HH:mm:ss"),
                                    //    MinStep = TimeSpan.FromSeconds(1).Ticks // 1초 단위 (Ticks 단위)
                                    //    // MinStep을 설정하면 축의 최소 간격을 지정할 수 있는데 DateTimePoint 데이터를 사용하는
                                    //    // 경우에는 제대로 동작하지 않는다. 이 경우에는 DateTimeAxis를 사용하는 것이 더 적합하다.
                                    //}

                                    // 1초 단위 축 생성 및 DateTime 포맷터 지정
                                    // 위 주석 처리된 Axis를 직접 생성하는 것보다 DateTimeAxis를 사용하는 것이 더 간단하고 직관적이다
                                    new DateTimeAxis(TimeSpan.FromSeconds(1), date => date.ToString("HH:mm:ss"))
                                    //{
                                    //    Name = "Time",
                                    //    MinStep = TimeSpan.FromSeconds(2).Ticks, // 최소 2초 간격 유지를 원하는 경우
                                    //    LabelsRotation = 15 // 라벨 회전 각도
                                    //}
                                },
                                // Y축 설정
                                //YAxes = new Axis[]
                                //{
                                //    new Axis
                                //    {
                                //        Labeler = value => value.ToString("F2") // 소수점 2자리까지 표시
                                //    }
                                //}
                            };

                            Controls.Add(cartesianChart);
                        }
                    }
                    catch (FileNotFoundException)
                    {
                        MessageBox.Show($"{parent.filePath} 파일이 존재하지 않습니다.");
                    }
                    catch (Exception ex)
                    {
                        MessageBox.Show($"오류 발생: {ex.Message}");
                    }
                }
        }
    }
}

프로젝트를 빌드하고 실행한다.

Record 버튼을 클릭해 로그 파일을 생성하고 Show 버튼을 클릭해 원하는 로그 파일을 선택하면 리스트 박스에 로그가 표시된다.

Form1에서 Graph 버튼을 클릭하면 Form2가 열리고 그래프가 표시된다.

마우스로 Zooming 및 Panning을 할 수 있다.

※ 참고

2026.04.20 - [C#] - [LiveCharts] 설치 및 기본 차트 그리기

[CFMEGA2] Serial Communication 시리얼 통신

J-sean — Thu, 9 Jul 2026 17:19:23 +0900

CFMEGA2는 2개의 RS232 통신 채널이 있다.

컴퓨터와 USB로 연결하고 시리얼 통신을 하는 경우는 아래 링크의 예와 같이 그냥 Serial 클래스를 사용하면 되지만 RS232 통신을 위한 핀(TX, RX, SG)을 직접 사용해 통신하는 경우는 Serial1, Serial2 클래스를 사용해야 한다.

2021.03.24 - [Embedded] - Digital Temperature Sensor DS18B20 with Arduino - 아두이노 방수 온도 센서

Serial1(Tx1, Rx1, SG)에 연결

#include <OneWire.h>
#include <DallasTemperature.h>
#include <LowPower.h>

// Data wire is plugged into port 2 on the Arduino
#define ONE_WIRE_BUS 2
#define TEMPERATURE_PRECISION 9 // Lower resolution

// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
OneWire oneWire(ONE_WIRE_BUS);

// Pass our oneWire reference to Dallas Temperature.
DallasTemperature sensors(&oneWire);

int numberOfDevices; // Number of temperature devices found
uint8_t sensor[3][8] = { { 0x28, 0xB8, 0x22, 0x94, 0x65, 0x25, 0x06, 0x5F},
                         { 0x28, 0xBB, 0x38, 0x60, 0x65, 0x25, 0x06, 0xB8},
                         { 0x28, 0x82, 0xBD, 0x0B, 0x92, 0x25, 0x06, 0x29} };

void setup(void)
{
  // start Serial1 port
  Serial1.begin(9600);
  
  // Start up the library
  sensors.begin();

  // Grab a count of devices on the wire
  numberOfDevices = sensors.getDeviceCount();

  // locate devices on the bus
  Serial1.print("Locating devices... ");
  Serial1.print("Found ");
  Serial1.print(numberOfDevices, DEC);
  Serial1.println(" devices.");

  // report parasite power requirements
  Serial1.print("Parasite power is: ");
  if (sensors.isParasitePowerMode())
    Serial1.println("ON");
  else
    Serial1.println("OFF");
  
  Serial1.print("Setting resolution to ");
  Serial1.println(TEMPERATURE_PRECISION, DEC);

  // set the resolution to 9 bit per device
  for (uint8_t i = 0; i < numberOfDevices; i++){
    if (!sensors.setResolution(sensor[i], TEMPERATURE_PRECISION))
      Serial1.print("Failed to set resolution");
  }
  
  for (uint8_t i = 0; i < numberOfDevices; i++){
    Serial1.print("Sensor ");
    Serial1.print(i);
    Serial1.print(" Resolution: ");
    Serial1.println(sensors.getResolution(sensor[i]), DEC);
  }  
}

// function to print the temperature for a device
void printTemperature(DeviceAddress deviceAddress, uint8_t id)
{
  float tempC = sensors.getTempC(deviceAddress);
  if (tempC == DEVICE_DISCONNECTED_C)
  {
    Serial1.println("Error: Could not read temperature data");
    return;
  }
  Serial1.print(id);
  Serial1.print(": ");
  Serial1.print(tempC);  
  Serial1.println("°C");
}

void loop (void)
{
  // call sensors.requestTemperatures() to issue a global temperature
  // request to all devices on the bus
  sensors.requestTemperatures();

  for (uint8_t i = 0; i < numberOfDevices; i++){
    printTemperature(sensor[i], i);
  }
  Serial1.println("-----------");
  Serial1.flush();
  // Serial1.print()가 종료되어도 데이터를 전송하는데 시간이 걸린다.
  // 데이터를 다 보내기도 전에 LowPower.powerDown()가 실행되면 아두이노가 바로 잠들어 버린다.
  // 아두이노가 잠들기 전에 Serial1.flush()로 시리얼 버퍼에 남은 데이터를 모두 전송해야 한다.
  // digitalWrite() 등으로 LED나 다른 하드웨어를 작동시키고 있었다면 delay(100) 같은 명령으로
  // 반응할 수 있는 최소한의 시간을 주어야 한다.

  LowPower.powerDown(SLEEP_1S, ADC_OFF, BOD_OFF);
  // SLEEP_1S: 아두이노를 1초 동안 잠들게 한다.
  // ADC_OFF: 잠자는 동안 아날로그 센서를 읽는 기능(ADC)을 꺼서 전기를 아낀다.
  // BOD_OFF: 저전압 감지 기능(BrownOut Detection)을 꺼서 전기를 더 많이 아낀다.
}

Serial1 클래스를 사용해 코드를 작성한다.

[Hugging Face] Datasets 데이터셋

J-sean — Sun, 5 Jul 2026 19:58:07 +0900

Hugging Face Datasets 라이브러리를 사용해 보자.

import datasets

dataset = datasets.load_dataset("jaehy12/news3")
print(dataset)

처음 실행하면 데이터셋을 다운로드한다. C:\Users\Sean\.cache\huggingface\hub\datasets--msarmi9--korean-english-multitarget-ted-talks-task

import datasets

dataset = datasets.load_dataset("msarmi9/korean-english-multitarget-ted-talks-task")
print(dataset["train"])
print(dataset["train"].features)
print(dataset["train"][0])
print("-"*50)
print(dataset["validation"])
print(dataset["validation"].features)
print(dataset["validation"][0])

import datasets

# train, valudation, test 데이터셋 직접 만들기
data_dict = {
	"train": [
		{"text": "I love programming.", "label": 1},
		{"text": "Python is my favorite language.", "label": 1},
		{"text": "I hate bugs in my code.", "label": 0},
		{"text": "Debugging is a frustrating process.", "label": 0},
		{"text": "I enjoy solving complex problems.", "label": 1},
		{"text": "I dislike syntax errors.", "label": 0},
		{"text": "I find coding to be a rewarding experience.", "label": 1},
		{"text": "I get frustrated when my code doesn't work.", "label": 0},
		{"text": "I love learning new programming languages.", "label": 1},
		{"text": "I find it challenging to debug my code.", "label": 0}
	],
	"validation": [
		{"text": "I enjoy writing clean and efficient code.", "label": 1},
		{"text": "I find it difficult to understand complex algorithms.", "label": 0},
		{"text": "I love collaborating with other developers.", "label": 1},
		{"text": "I get frustrated when I encounter unexpected errors.", "label": 0},
		{"text": "I enjoy learning new programming paradigms.", "label": 1}
	],
	"test": [
		{"text": "I find it rewarding to solve challenging coding problems.", "label": 1},
		{"text": "I dislike spending hours debugging my code.", "label": 0},
		{"text": "I love exploring new programming frameworks.", "label": 1},
		{"text": "I get frustrated when I can't find a solution to a coding problem.", "label": 0},
		{"text": "I enjoy optimizing my code for better performance.", "label": 1}
	]
}

# 데이터셋을 Hugging Face Datasets 라이브러리의 DatasetDict로 변환
dataset = datasets.DatasetDict({
	"train": datasets.Dataset.from_list(data_dict["train"]),
	"validation": datasets.Dataset.from_list(data_dict["validation"]),
	"test": datasets.Dataset.from_list(data_dict["test"])
})

# 데이터셋 확인
print(dataset)
print(dataset["train"].features)
print(dataset["train"][0])

# 파일로 저장
dataset.save_to_disk("my_dataset")

프로젝트 폴더\my_dataset

import datasets

# train, valudation, test 데이터셋 직접 만들기
data_dict = {
	"text": [
		"I love programming.",
		"Python is my favorite language.",
		"I hate bugs in my code.",
		"Debugging is a frustrating process.",
		"I enjoy solving complex problems.",
		"I dislike syntax errors.",
		"I find coding to be a rewarding experience.",
		"I get frustrated when my code doesn't work.",
		"I love learning new programming languages.",
		"I find it challenging to debug my code.",
		"I enjoy writing clean and efficient code.",
		"I find it difficult to understand complex algorithms.",
		"I love collaborating with other developers.",
		"I get frustrated when I encounter unexpected errors.",
		"I enjoy learning new programming paradigms.",
		"I find it rewarding to solve challenging coding problems.",
		"I dislike spending hours debugging my code.",
		"I love exploring new programming frameworks.",
		"I get frustrated when I can't find a solution to a coding problem.",
		"I enjoy optimizing my code for better performance."
	],
	"label": [1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1]
}

# 데이터를 Hugging Face Datasets 형식으로 변환
dataset = datasets.Dataset.from_dict(data_dict)
# 데이터셋 확인
print(dataset)
print(dataset[0])  # 첫 번째 데이터 확인
print("-"*50)

# 데이터셋을 train, test로 분리
split_dataset = dataset.train_test_split(test_size=0.2)
train_dataset = split_dataset["train"]
test_dataset = split_dataset["test"]

# 데이터셋 확인
print(train_dataset)
print(train_dataset[0])  # 첫 번째 train 데이터 확인
print("-"*50)
print(test_dataset)
print(test_dataset[0])  # 첫 번째 test 데이터 확인

※ 참고

Datasets

[Hugging Face] Hugging Face Python Libraries 허깅 페이스 파이썬 라이브러리

J-sean — Sat, 4 Jul 2026 22:43:52 +0900

허깅 페이스 파이썬 라이브러리를 사용해 보자.

import huggingface_hub

huggingface_hub.login(token="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")

# 로그인 후 사용자 정보 가져오기
user_info = huggingface_hub.whoami()
print(user_info['fullname'])

# 로그아웃
huggingface_hub.logout()

from huggingface_hub import InferenceClient

# 기본 질문-응답(question answering) 모델을 사용하여 질문에 대한 답변 생성
client = InferenceClient(token="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")
answer = client.question_answering(question="What is the capital of France?",
								   context="France is a country in Europe. Its capital is Paris.")
print(answer)
#print(answer.answer)

# 대화(conversational) 모델을 사용하여 대화 생성
client = InferenceClient(token="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",
						 model="Qwen/Qwen2.5-7B-Instruct")
messages = [{"role": "user", "content": "프랑스의 수도는 어디야?"}]
answer = client.chat_completion(messages=messages, max_tokens=100)
print(answer)
#print(answer.choices[0].message.content)

# 이미지 생성(text-to-image) 모델을 사용하여 텍스트를 기반으로 이미지 생성
client = InferenceClient(token="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",
						 model="stabilityai/stable-diffusion-xl-base-1.0")
image = client.text_to_image("A beautiful sunset over the mountains.")
image.save("sunset.png")

모델에 따라 답변 및 여러 가지 정보가 생성된다.

텍스트에 따른 이미지를 생성한다.

from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen3-0.6B", dtype="auto", device_map="auto")
# 미리 학습된 인과적 언어 모델을 로드한다.
print(model._get_name())

처음 실행하면 모델을 다운로드받고 이름을 출력한다. (C:\Users\Sean\.cache\huggingface\hub\models--Qwen--Qwen3-0.6B)

다음 실행부터는 다운로드된 모델을 로딩만 한다.

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained(pretrained_model_name_or_path="Qwen/Qwen3-0.6B")
# 미리 학습된 모델의 토크나이저를 불러오는 코드이다. "Qwen/Qwen3-0.6B"는 모델의 이름을 나타낸다.

result = tokenizer("Hello, how are you?", return_tensors="pt")
# pt: PyTorch를 나타내며, return_tensors="pt"는 토큰화된 결과를 PyTorch 텐서 형식으로 반환하도록 지정하는 것이다.
print(result)

처음 실행 시 필요한 파일을 다운로드한다. 이후 실행 시 마지막 결과만 출력된다.

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained(pretrained_model_name_or_path="Qwen/Qwen2.5-7B-Instruct")
# 미리 학습된 모델의 토크나이저를 불러오는 코드이다. "Qwen/Qwen2.5-7B-Instruct"는 모델의 이름을 나타낸다.

result = tokenizer("Hello, how are you?", return_tensors="pt")
# pt: PyTorch를 나타내며, return_tensors="pt"는 토큰화된 결과를 PyTorch 텐서 형식으로 반환하도록 지정하는 것이다.
print(result)

다른 모델을 사용했지만 토큰화 결과는 같다. (같은 Qwen 모델이라 그런거 같다)

LGAI-EXAONE 모델을 사용하면 토큰화 결과가 달라진다.

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained(pretrained_model_name_or_path="LGAI-EXAONE/EXAONE-4.0-1.2B")
result = tokenizer("Hello, how are you?", return_tensors="pt")
print(result)

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained(pretrained_model_name_or_path="Qwen/Qwen2.5-7B-Instruct")
# 미리 학습된 모델의 토크나이저를 불러오는 코드이다. "Qwen/Qwen2.5-7B-Instruct"는 모델의 이름을 나타낸다.

result = tokenizer("Hello, how are you?", return_tensors="pt")
# pt: PyTorch를 나타내며, return_tensors="pt"는 토큰화된 결과를 PyTorch 텐서 형식으로 반환하도록 지정하는 것이다.
print(result)

result = tokenizer.encode("Hello, how are you?", return_tensors="pt")
# encode() 메서드는 입력 텍스트를 토큰화하고, 토큰 ID만 반환하는 메서드이다.
print(result)

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained(pretrained_model_name_or_path="Qwen/Qwen2.5-7B-Instruct")
# 미리 학습된 모델의 토크나이저를 불러오는 코드이다. "Qwen/Qwen2.5-7B-Instruct"는 모델의 이름을 나타낸다.

result = tokenizer.encode("Hello, how are you?", return_tensors="pt")
# encode() 메서드는 입력 텍스트를 토큰화하고, 토큰 ID만 반환하는 메서드이다.
print(result)

result = tokenizer.decode(result[0], skip_special_tokens=True)
# decode() 메서드는 토큰 ID를 다시 텍스트로 변환하는 메서드이다.
# clean_up_tokenization_spaces=True 옵션은 토큰화 과정에서 생긴 불필요한 공백을 제거하는 옵션이다.
print(result)

from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "LGAI-EXAONE/EXAONE-4.0-1.2B"
model = AutoModelForCausalLM.from_pretrained(model_name, dtype="bfloat16", device_map="auto")
tokenizer = AutoTokenizer.from_pretrained(model_name)

prompt = "네가 얼마나 대단한지 설명해 봐"

messages = [
    {"role": "user", "content": prompt}
]
inputs = tokenizer.apply_chat_template(
    messages,
    tokenize=True,
    add_generation_prompt=True,
    return_tensors="pt",
    return_dict=True
).to(model.device)
# .to(model.device): 모델이 실행되는 장치(GPU 또는 CPU)로 입력 데이터를 이동시키는 역할을 함.

output = model.generate(
    **inputs,
    max_new_tokens=256,
    do_sample=False,
)
# **inputs의 의미: inputs 딕셔너리의 키-값 쌍을 언패킹하여 model.generate 함수에 전달하는 것.
# 즉, inputs 딕셔너리의 각 항목이 model.generate 함수의 인자로 전달됨.
# do_sample=False의 의미: 모델이 생성할 텍스트를 결정할 때 무작위성을 배제하고,
# 가장 가능성이 높은 토큰을 선택하도록 설정하는 것.

print(tokenizer.decode(output[0]))

EXAONE

from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "QWen/Qwen3-0.6B"
model = AutoModelForCausalLM.from_pretrained(model_name, dtype="bfloat16", device_map="auto")
tokenizer = AutoTokenizer.from_pretrained(model_name)

prompt = "네가 얼마나 대단한지 설명해 봐"

messages = [
    {"role": "user", "content": prompt}
]
inputs = tokenizer.apply_chat_template(
    messages,
    tokenize=True,
    add_generation_prompt=True,
    return_tensors="pt",
    return_dict=True
).to(model.device)
# .to(model.device): 모델이 실행되는 장치(GPU 또는 CPU)로 입력 데이터를 이동시키는 역할을 함.

output = model.generate(
    **inputs,
    max_new_tokens=256,
    do_sample=False,
)
# **inputs의 의미: inputs 딕셔너리의 키-값 쌍을 언패킹하여 model.generate 함수에 전달하는 것.
# 즉, inputs 딕셔너리의 각 항목이 model.generate 함수의 인자로 전달됨.
# do_sample=False의 의미: 모델이 생성할 텍스트를 결정할 때 무작위성을 배제하고,
# 가장 가능성이 높은 토큰을 선택하도록 설정하는 것.

print(tokenizer.decode(output[0]))

QWen

from transformers import pipeline

generator = pipeline(task='text-generation', model='LGAI-EXAONE/EXAONE-4.0-1.2B')
# EXAONE과 같은 인스트럭션(대화형) 튜닝 모델은 챗 템플릿 형식으로 프롬프트를 전달해야 올바른 답변이 나온다.
messages = [
    {"role": "user", "content": "한국의 수도는 어디야?"}
]

# return_full_text=False를 주면 질문은 제외하고 생성된 답변만 반환한다.
result = generator(messages, return_full_text=False)

print(result)
#print(result[0]['generated_text'])

EXAONE

from transformers import pipeline

generator = pipeline(task='text-generation', model='QWen/Qwen3-0.6B')
messages = [
    {"role": "user", "content": "한국의 수도는 어디야?"}
]

# return_full_text=False를 주면 질문은 제외하고 생성된 답변만 반환한다.
result = generator(messages, return_full_text=False)

print(result)
#print(result[0]['generated_text'])

QWen

※ 참고

Hub Python Library

Transformers Tokenizers

Datasets

[CFMEGA2] Hardware SPI Communication Pin

J-sean — Sun, 28 Jun 2026 14:08:38 +0900

CFMEGA2는 노이즈 보호를 위해 8개(5, 6, 7, 8, 9, 11, 12, 42)의 지정된 GPIO 단자만 나와 있다.

하드웨어 SPI 핀이 필요하다면 CF-SHIELD를 연결해야 한다. 소프트웨어 SPI 통신을 한다면 아무 GPIO 핀을 이용해도 된다.

CF-SHIELD는 CFMEGA2에 나와 있지 않은 4번, 10번 GPIO 및 하드웨어 SPI 통신 핀, 그리고 몇 개의 전원선을 가져온다. 그 외의 다른 핀들은 연결되지 않는다.

[CFMEGA2] OMRON E8Y Pressure Sensor 압력 센서

J-sean — Thu, 25 Jun 2026 21:25:33 +0900

CFMEGA2에서 OMRON E8Y 압력 센서를 사용해 보자.

정확히 이 모델을 사용한 건 아니다.

// CFMEGA2에서 A0~A3은 0~20mA 전류값을 0~1023의 디지털 값으로 변환한다. (Analog to Digital Converter)
// OMRON E8Y 압력 센서는 압력에 따라 4~20mA의 아날로그 전류를 출력한다.
//
// 4mA의 ADC 값: 약 204 (1023의 20%)
// 20mA의 ADC 값: 1023
//
// 그럼 이론적으로는 CFMEGA2에서 204~1023의 값을 감지할 것이다. (범위: 819)
// 하지만 압력 센서를 연결하고 압력을 가하지 않은 상태의 값을 확인해 보면 195,
// 센서가 감지할 수 있는 최대 압력을 가한 상태의 값을 확인해 보면 985가 나온다. (범위: 790)
//
// 실제 값에 맞게 보정해 주어야 한다.

const int sensorPin = A0;  // 0~20mA 전용 입력 핀에 연결 (회색 선).
const float maxPressure = 1000.0f; // 압력 센서 데이터시트에 기재된 최대 측정 압력값. (1,000Pa)
const float maxCurrent = 20.0f; // 압력 센서 데이터시트에 기재된 최대 측정 전류값.
const int initialADCValue = 195; // 압력이 없을때 ADC 값으로 195가 들어온다.
const int maxADCValue = 985; // 최대 압력일때 ADC 값으로 985가 들어온다.

void setup() {
  Serial.begin(9600);
  Serial.println("----------- CFMEGA2 Pressure Measure Start -----------");
}

void loop() {
  int adcValue = analogRead(sensorPin);
  
  // 센서 단선 또는 전원 오류 확인 (4mA 미만 확인)
  // 오차를 감안해 ADC 값이 190(약 3.7mA) 미만으로 떨어지면 오류로 간주
  if (adcValue < 190) {
    Serial.println("Error: Weak Sensor Signal. Check the sensor or the cable.");
  } else {
    // ADC 값(204~1023)을 압력(0~maxPressure)으로 비례 변환
    float pressure = (adcValue - initialADCValue) * (maxPressure / (maxADCValue - initialADCValue));
    // 값 보정: 실제 센서에 압력이 전혀 안 걸려 있을 때 출력되는 전류가 정확히
    // 4mA(ADC 204)가 아닐 수 있다. 초기값이 미세하게 맞지 않는다면 initialADCValue 값을
    // 실제 측정된 초기 ADC 값으로 조금씩 수정하여 보정한다.
    // 내 경우엔 195다. 최대 압력이 걸렸을때는 1023이 아니라 985다.

    // 센서에서 현재 출력되는 전류(mA) 역산
    float current_mA = adcValue * (maxCurrent / maxADCValue);
    
    Serial.print("adc: ");
    Serial.print(adcValue);
    Serial.print("  |  Current: ");
    Serial.print(current_mA, 2); // 소수점 둘째 자리까지 출력
    Serial.print(" mA  |  Pressure: ");
    Serial.print(pressure, 2);
    Serial.println(" Pa");
  }
  
  delay(1000); // 1초 대기
}

센서 데이터가 표시된다.

이번엔 아스키 문자가 아닌 바이너리 데이터를 전달해 보자.

const int sensorPin = A0;  // 0~20mA 전용 입력 핀에 연결 (회색 선)
const float maxPressure = 1000.0f; // 압력 센서 데이터시트에 기재된 최대 측정 압력값
const float maxCurrent = 20.0f; // 압력 센서 데이터시트에 기재된 최대 측정 전류값
const int initialADCValue = 195; // 압력이 없을때 ADC 값으로 195가 들어온다.
const int maxADCValue = 985; // 최대 압력일때 ADC 값으로 985가 들어온다.

void setup() {
  Serial.begin(9600);
  //Serial.println("----------- CFMEGA2 Pressure Measure Start -----------");
}

void loop() {
  int adcValue = analogRead(sensorPin);
  
  // 센서 단선 또는 전원 오류 확인 (4mA 미만 확인)
  // 오차를 감안해 ADC 값이 190(약 3.7mA) 미만으로 떨어지면 오류로 간주
  if (adcValue < 190) {
    Serial.println("Error: Weak Sensor Signal. Check the sensor or the cable.");
  } else {
    // ADC 값(204~1023)을 압력(0~maxPressure)으로 비례 변환
    float pressure = (adcValue - initialADCValue) * (maxPressure / (maxADCValue - initialADCValue));
    // 값 보정: 실제 센서에 압력이 전혀 안 걸려 있을 때 출력되는 전류가 정확히
    // 4mA(ADC 204)가 아닐 수 있다. 초기값이 미세하게 맞지 않는다면 initialADCValue 값을
    // 실제 측정된 초기 ADC 값으로 조금씩 수정하여 보정한다.
    // 내 경우엔 195다. 최대 압력이 걸렸을때는 1023이 아니라 985다.

    // 센서에서 현재 출력되는 전류(mA) 역산
    float current_mA = adcValue * (maxCurrent / maxADCValue);
    
    //Serial.print("adc: ");
    //Serial.print(adcValue);
    //Serial.print("  |  Current: ");
    //Serial.print(current_mA, 2); // 소수점 둘째 자리까지 출력
    //Serial.print(" mA  |  Pressure: ");
    //Serial.print(pressure, 2);
    //Serial.println(" Pa");
    
    // CFMEGA2(Arduino)의 int는 2바이트(16비트) 크기를 가진다.
    Serial.write(highByte((int)pressure)); // 상위 1바이트(8비트) 먼저 전송
    Serial.write(lowByte((int)pressure)); // 하위 1바이트(8비트) 이어서 전송
  }
  
  delay(1000); // 1초 대기
}

아스키 문자가 아닌 바이너리 데이터이기 때문에 Arduino IDE의 Serial Monitor를 통해 확인하면 알 수 없는 문자가 표시된다.

시리얼 통신용 프로그램을 사용하면 바이너리 데이터를 직접 확인할 수 있다.

1초당 2바이트씩 데이터를 읽는다. 처음 4초간은 압력이 없기 때문에 00 01이 4번 입력되고 5초에 177 Pa의 압력이 가해져 00 B1이 입력되었다.

센서가 출력하는 전류값이나 CFMEGA2가 읽는 전류값은 높은 정밀도를 가질 수 없을 것이다.

압력이 없을 때 센서를 통해 CFMEGA2에 들어온 ADC값이 처음엔 195였는데 몇 번 테스트하는 과정에서 196으로 바뀌었고 변환 과정을 거쳐 압력은 1로 표시되었다. 최대 압력일 때 ADC값도 최초 985에서 986으로 바뀌었다. 986은 변환식을 통해 1001이 된다.

예) (h): HEX, (d): DEC

■ 00 01(h): 1(d)

■ 00 B1(h): 177(d)

■ 01 20(h): 288(d)

...

■ 03 E9(h): 1001(d)

[vLLM] WSL에서 vLLM 서버 실행하고 사용하기

J-sean — Sun, 21 Jun 2026 13:59:35 +0900

아래 링크와 같이 WSL에 설치한 vLLM 서버를 실행하고 사용해 보자.

2026.06.19 - [AI, ML, DL] - [vLLM] WSL 에서 vLLM 설치 및 간단한 실행

Background에서 서버를 실행하고 프로세스를 확인.

■ 서버 실행하기 (Foreground에서 실행된다)

VLLM_USE_FLASHINFER_SAMPLER=0 python3 -m vllhttp://m.entrypoints.openai.api_server --model LGAI-EXAONE/EXAONE-Deep-2.4B-AWQ --trust_remote_code True --gpu_memory_utilization=0.7

■ 서버 실행하기 (Background에서 실행되고 vllm.log 파일에 로그가 기록된다)

VLLM_USE_FLASHINFER_SAMPLER=0 python3 -m vllhttp://m.entrypoints.openai.api_server --model LGAI-EXAONE/EXAONE-Deep-2.4B-AWQ --trust_remote_code True --gpu_memory_utilization=0.7 > vllm.log 2>&1 &

VLLM_USE_FLASHINFER_SAMPLER=0은 vLLM이 다음 토큰을 선택(샘플링)할 때 FlashInfer 라이브러리의 고속 커널을 사용하지 않고, PyTorch/Triton 기반의 기본 내장 샘플러를 사용하도록 강제하는 환경 변수 설정이다. 내 시스템에선 이 옵션 없이는 실행할 수 없었다.

■ 백그라운드에서 동작중인 서버 프로세스 확인 (백그라운드에서 동작하는 프로세스 중 vllm이라는 문자열과 VLLM이라는 문자열을 검색한다)

ps -ef | grep -E "vllm|VLLM"

■ 백그라운드 서버 종료

pkill -f vllhttp://m.entrypoints.openai.api_server

동작중인 서버를 이용해보자. 아래 코드를 작성하고 실행한다.

from openai import OpenAI

# vLLM 서버 주소 설정 (기본 포트 8000)
client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="vllm-token" # api_key는 아무 문자열이나 넣어도 된다.
)

# 단발성 답변 받기 (General Request)
print("=== 일반 답변 요청 ===")
response = client.chat.completions.create(
    model="LGAI-EXAONE/EXAONE-Deep-2.4B-AWQ",  # 동작중인 서버의 모델 이름과 일치해야 한다.
    messages=[
        {"role": "system", "content": "당신은 친절한 AI 도우미입니다."},
        {"role": "user", "content": "인공지능과 거대언어모델(LLM)의 차이점을 한 문장으로 설명해줘."}
    ],
    temperature=0.2,
    top_p=0.95,
    max_tokens=1024
)

print(response.choices[0].message.content)

print()

# 실시간 스트리밍 답변 받기 (Streaming Request)
print("=== 스트리밍 답변 요청 ===")
stream = client.chat.completions.create(
    model="LGAI-EXAONE/EXAONE-Deep-2.4B-AWQ",
    messages=[
        {"role": "system", "content": "당신은 친절한 AI 요리사 도우미 입니다."},
        {"role": "user", "content": "맛있는 김치찌개를 끓이는 비법을 짧게 알려줘."}
    ],
    temperature=0.2,
    top_p=0.95,
    max_tokens=1024,
    stream=True, # 스트리밍 활성화
)

for chunk in stream:
    if chunk.choices[0].delta.content is not None:
        print(chunk.choices[0].delta.content, end="", flush=True)

print()

답변 첫 부분에 빈 줄과 </thought> 태그가 따라 나온다.

불필요한 태그를 제거해 보자.

from openai import OpenAI

# vLLM 서버 주소 설정 (기본 포트 8000)
client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="vllm-token" # api_key는 아무 문자열이나 넣어도 된다.
)

# 단발성 답변 받기 (General Request)
print("=== 일반 답변 요청 ===")
response = client.chat.completions.create(
    model="LGAI-EXAONE/EXAONE-Deep-2.4B-AWQ",  # 동작중인 서버의 모델 이름과 일치해야 한다.
    messages=[
        {"role": "system", "content": "당신은 친절한 AI 도우미입니다."},
        {"role": "user", "content": "인공지능과 거대언어모델(LLM)의 차이점을 한 문장으로 설명해줘."}
    ],
    temperature=0.2,
    top_p=0.95,
    max_tokens=1024
)

#print(response.choices[0].message.content) # 태그 포함 답변 출력
content = response.choices[0].message.content

# </thought> 태그가 포함되어 있다면 분할 처리
if "</thought>" in content:
    # thought_process: 모델이 생각한 과정 (필요시 사용)
    # final_answer: 사용자가 원하는 최종 답변
    thought_process, final_answer = content.split("</thought>", 1)
    #print("=== [AI의 생각 과정] ===")
    #print(thought_process.replace("<thought>", "").strip()) # 시작 태그가 남아있다면 제거
    print(final_answer.strip())
else:
    # 태그가 없는 일반적인 경우 그대로 출력
    print(content)

print()

# 실시간 스트리밍 답변 받기 (Streaming Request)
print("=== 스트리밍 답변 요청 ===")
stream = client.chat.completions.create(
    model="LGAI-EXAONE/EXAONE-Deep-2.4B-AWQ",
    messages=[
        {"role": "system", "content": "당신은 친절한 AI 요리사 도우미 입니다."},
        {"role": "user", "content": "맛있는 김치찌개를 끓이는 비법을 짧게 알려줘."}
    ],
    temperature=0.2,
    top_p=0.95,
    max_tokens=1024,
    stream=True, # 스트리밍 활성화
)

# 실시간 문자열에서 불필요한 </thought> 태그 처리를 위한 변수 선언
full_text = ""
has_passed_thought = False

for chunk in stream:
    if chunk.choices[0].delta.content is not None:
        #print(chunk.choices[0].delta.content, end="", flush=True) # 태그 포함 답변 출력

        token = chunk.choices[0].delta.content
        full_text += token  # 들어오는 토큰을 전체 버퍼에 누적

        # </thought> 태그가 지나갔는지 확인
        if not has_passed_thought:
            if "</thought>" in full_text:
                # 태그가 끝나는 지점을 찾아 그 이후의 텍스트만 추출
                _, final_start_text = full_text.split("</thought>", 1)
                has_passed_thought = True
                
                # 태그 뒤에 공백이나 줄바꿈이 있다면 깔끔하게 지우고 첫 출력
                first_output = final_start_text.lstrip()
                if first_output:
                    print(first_output, end="", flush=True)
            else:
                # 아직 </thought> 태그가 나오기 전(생각 중)이라면 화면에 출력하지 않고 건너뛴다.
                continue
        else:
            # 만약 앞서 출력된 내용이 아직 아무것도 없다면 (sys.stdout이 비어있음)
            # 다음에 들어오는 토큰들도 첫 글자가 나올 때까지 앞쪽 공백/줄바꿈을 계속 지워준다.
            if not full_text.split("</thought>", 1)[1].lstrip():
                # 여전히 공백이나 줄바꿈만 들어오는 상태이므로 출력하지 않고 스킵.
                continue
                
            # 글자가 들어오기 시작하면, 그 시점의 토큰부터 그대로 출력.
            # (단, 공백이 섞여 들어왔을 수 있으므로 첫 진입 토큰만 lstrip 처리)
            if len(full_text.split("</thought>", 1)[1].lstrip()) == len(token):
                print(token.lstrip(), end="", flush=True)
            else:
                print(token, end="", flush=True)

print()

불필요한 태그 없이 깔끔하게 정리되었다.

또한 WSL에 서버를 실행한 상태에서 네이티브 윈도우에서도 위와 동일한 코드로 LLM을 사용할 수 있다.

아니면 WSL에서 hostname -I 명령으로 확인한 IP 주소값을 base_url에 넣어도 된다.

from openai import OpenAI

# vLLM 서버 주소 설정 (기본 포트 8000)
client = OpenAI(
    base_url="http://localhost:8000/v1",
    #base_url="http://172.21.167.101:8000/v1",
    api_key="vllm-token" # api_key는 아무 문자열이나 넣어도 된다.
)

# 단발성 답변 받기 (General Request)
print("=== 일반 답변 요청 ===")
response = client.chat.completions.create(
    model="LGAI-EXAONE/EXAONE-Deep-2.4B-AWQ",  # 동작중인 서버의 모델 이름과 일치해야 한다.
    messages=[
        {"role": "system", "content": "당신은 친절한 AI 도우미입니다."},
        {"role": "user", "content": "인공지능과 거대언어모델(LLM)의 차이점을 한 문장으로 설명해줘."}
    ],
    temperature=0.2,
    top_p=0.95,
    max_tokens=1024
)

print(response.choices[0].message.content)

print()

# 실시간 스트리밍 답변 받기 (Streaming Request)
print("=== 스트리밍 답변 요청 ===")
stream = client.chat.completions.create(
    model="LGAI-EXAONE/EXAONE-Deep-2.4B-AWQ",
    messages=[
        {"role": "system", "content": "당신은 친절한 AI 요리사 도우미 입니다."},
        {"role": "user", "content": "맛있는 김치찌개를 끓이는 비법을 짧게 알려줘."}
    ],
    temperature=0.2,
    top_p=0.95,
    max_tokens=1024,
    stream=True, # 스트리밍 활성화
)

for chunk in stream:
    if chunk.choices[0].delta.content is not None:
        print(chunk.choices[0].delta.content, end="", flush=True)

print()

네이티브 윈도우에서 WSL 서버 사용.

※ 참고

LG AI Research의 공식 가이드에 따르면 EXAONE Deep 모델은 시스템 프롬프트를 지원하지 않거나 권장하지 않는다. 시스템 프롬프트를 넣으면 모델이 지시사항을 무시하거나 추론(<thought>)을 시작하지 못하고 엉뚱한 답변을 낼 확률이 높아진다. 요리사 같은 페르소나는 아래와 같이 user 메시지 안에 녹여내자.

response = client.chat.completions.create(
    model="LGAI-EXAONE/EXAONE-Deep-2.4B-AWQ",
    messages=[
        # 시스템 프롬프트를 없애고 유저 메시지에 역할을 녹여낸다.
        {"role": "user", "content": "당신은 친절한 AI 도우미입니다. 인공지능과 거대언어모델(LLM)의 차이점을 한 문장으로 설명해줘."}
    ],
    temperature=0.2,
    top_p=0.95,
    max_tokens=1024
)

[vLLM] WSL에서 vLLM 설치 및 간단한 실행

J-sean — Fri, 19 Jun 2026 13:29:38 +0900

WSL에서 vLLM을 사용해보자.

■ WSL을 설치한다. 운영체제는 우분투 24.04를 설치한다.

우분투 26.04는 파이썬 3.14가 설치되어 있는데 현재 파이토치가 파이썬 3.13까지만 지원하기 때문에 파이토치 설치가 귀찮아진다.

■ pip3를 설치한다.

sudo apt update

sudo apt upgrade

sudo apt install python3-pip

pip3 --version (정상 설치 확인)

■ 파이썬 가상환경을 만들어 주는 venv를 설치한다.

sudo apt install python3-venv

가상환경 생성 및 확인

가상환경 활성화

■ venv-vllm 디렉토리에 가상환경을 생성하고 활성화한다.

python3 -m venv venv-vllm

source venv-vllm/bin/activate

■ 파이토치를 설치한다. (CUDA 12.4)
pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu124

vllm을 설치하면 많은 프로그램이 설치된다.

■ vLLM을 설치한다.

pip3 install vllm

■ vLLM을 실행하기 위해 CUDA Toolkit을 설치한다. (Cuda Toolkit 12.4)

wget https://developer.download.nvidia.com/compute/cuda/12.4.0/local_installers/cuda_12.4.0_550.54.14_linux.run

sudo sh cuda_12.4.0_550.54.14_linux.run

위 명령을 실행하면 잠시 멈춘 것처럼 시간이 좀 걸린다. 그리고 accept를 입력하고 다음 화면에서 CUDA Toolkit 12.4가 선택된 상태에서 Install을 선택한다. Driver는 옵션에 없었지만 있다면 선택해제한다. Driver를 설치하는 것이 아니다.

설치가 끝나면 아래와 같이 환경 변수를 등록한다.

nano ~/.bashrc 실행하고 파일 끝에 아래 내용 추가

export PATH=/usr/local/cuda-12.4/bin${PATH:+:${PATH}}
export LD_LIBRARY_PATH=/usr/local/cuda-12.4/lib64${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}}

source ~/.bashrc 실행 (이 명령을 실행하고 나면 파이썬 가상환경이 풀린다)
nvcc --version 명령을 실행하면 버전이 표시된다.

■ vLLM에서 LGAI EXAON 모델을 사용하는 예

import os

# vLLM에서 FlashInfer 기반의 고속 셈플링(Sampling) 기능을 끄고, 안정적인 PyTorch 네이티브(기본)
# 셈플링 방식으로 되돌리기(Fallback).
os.environ["VLLM_USE_FLASHINFER_SAMPLER"] = "0"
# vLLM은 내부적으로 가속 연산을 위해 FlashInfer라는 라이브러리를 사용하는데 이 라이브러리는
# NVIDIA Turing 아키텍처(Compute Capability sm75) 이상의 GPU에서만 작동한다. 사용하는 그래픽카드가
# 소형 모델 구동용(VRAM 8GB 수준)이면서 sm75보다 낮은 구형 아키텍처(예: GTX 10시리즈인 Pascal 아키텍처 sm61 등)
# 이면 문제가 발생한다.
# 해결 방법: vllm 패키지를 로드하기 전에 os.environ을 통해 FlashInfer 가속 비활성화하기

from vllm import LLM, SamplingParams

def main():
    # 모델 로드
    llm = LLM(
        model="LGAI-EXAONE/EXAONE-Deep-2.4B-AWQ", 
        trust_remote_code=True, 
        gpu_memory_utilization=0.7
    )
# vLLM은 기본적으로 GPU 메모리의 90%(0.9)를 미리 할당하기 때문에, 낮은 성능의 GPU에서는
# OOM(메모리 부족) 에러를 방지하거나 다른 프로세스와 GPU를 나누어 쓰려면 gpu_memory_utilization
# 옵션이 필수적이다.

    # 파라미터 설정
    sampling_params = SamplingParams(
        temperature=0.0,
        top_p=0.95,
        max_tokens=1024,
        repetition_penalty=1.1
    )

    # 질문 리스트
    raw_questions = [
        "대한민국의 수도는 어디인가요?",
        "인공지능은 무엇인가요?"
    ]

    # vLLM 공식 Chat Template 적용
    prompts = []
    tokenizer = llm.get_tokenizer()
    for q in raw_questions:
        messages = [{"role": "user", "content": q}]
        formatted_prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
        prompts.append(formatted_prompt)

    # 텍스트 생성
    outputs = llm.generate(prompts, sampling_params)

    # 결과 출력 (내장함수로 태그 뒤쪽만 추출)
    for i, output in enumerate(outputs):
        prompt = raw_questions[i]
        # output.prompt로 프롬프트를 추출할 수도 있지만 불필요한 태그가 많이 따라온다. 정제과정이 필요.
        generated_text = output.outputs[0].text
        
        # </thought> 태그가 존재한다면 그 태그 뒷부분([1])만 추출한다
        if "</thought>" in generated_text:
            clean_answer = generated_text.split("</thought>")[1]
        else:
            clean_answer = generated_text

        print(f"==========================================")
        print(f"질문: {prompt}")
        print(f"답변: {clean_answer.strip()}")
        print(f"==========================================\n")

if __name__ == "__main__":
    main()

EXAON 모델이 다운로드되어 있지 않다면 다운로드하느라 이 화면에서 시간이 좀 걸린다.

위 코드에서는 토큰 없이 허가되지 않은 접근을 하고 있기 때문에 다운로드가 느리다고 한다. 토큰을 받고 빠르게 다운로드하는 방법은 맨 아래 내용을 참고하자.

최종 결과 화면

다시 실행하면 모델을 다운로드하는 과정이 없다.

import os
os.environ["VLLM_USE_FLASHINFER_SAMPLER"] = "0"

from vllm import LLM, SamplingParams

def main():
    llm = LLM(
        model="LGAI-EXAONE/EXAONE-Deep-2.4B-AWQ", 
        trust_remote_code=True, 
        gpu_memory_utilization=0.7
    )

    sampling_params = SamplingParams(
        temperature=0.0,
        top_p=0.95,
        max_tokens=1024,
        repetition_penalty=1.1
    )

    raw_questions = [
        "대한민국의 수도는 어디인가요?",
        "인공지능에 대해 한 문장으로 요약해줘."
    ]

    prompts = []
    tokenizer = llm.get_tokenizer()
    for q in raw_questions:
        messages = [{"role": "user", "content": q}]
        formatted_prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
        prompts.append(formatted_prompt)

    outputs = llm.generate(prompts, sampling_params)

    for i, output in enumerate(outputs):
        prompt = raw_questions[i]
        generated_text = output.outputs[0].text
        
        if "</thought>" in generated_text:
            clean_answer = generated_text.split("</thought>")[1]
        else:
            clean_answer = generated_text

        print(f"==========================================")
        print(f"질문: {prompt}")
        print(f"답변: {clean_answer.strip()}")
        print(f"==========================================\n")

    print(outputs)

if __name__ == "__main__":
    main()

짧은 답변이 나오도록 질문을 바꾸고 전체 결과가 출력되도록 print(outputs) 명령을 추가했다.

마지막에 outputs의 내용이 출력되었다.

[RequestOutput(request_id=0, prompt='[|system|][|endofturn|]\n[|user|]대한민국의 수도는 어디인가요?\n[|assistant|]<thought>\n', prompt_token_ids=[420, 453, 47982, 453, 422, 361, 560, 420, 453, 14719, 453, 422, 36437, 730, 8952, 657, 4083, 798, 7799, 392, 560, 420, 453, 1167, 8659, 453, 422, 389, 52040, 391, 560], encoder_prompt=None, encoder_prompt_token_ids=None, prompt_logprobs=None, outputs=[CompletionOutput(index=0, text='\n</thought>\n\n 대한민국의 수도는 서울(Seoul)입니다.', token_ids=[560, 2240, 52040, 391, 560, 560, 9971, 730, 8952, 657, 2879, 369, 8078, 10103, 370, 10996, 375, 361], routed_experts=None, cumulative_logprob=None, logprobs=None, finish_reason=stop, stop_reason=None)], finished=True, metrics=None, lora_request=None, num_cached_tokens=0), RequestOutput(request_id=1, prompt='[|system|][|endofturn|]\n[|user|]인공지능에 대해 한 문장으로 요약해줘.\n[|assistant|]<thought>\n', prompt_token_ids=[420, 453, 47982, 453, 422, 361, 560, 420, 453, 14719, 453, 422, 41595, 22427, 2373, 2409, 764, 13742, 13456, 16399, 999, 15887, 375, 560, 420, 453, 1167, 8659, 453, 422, 389, 52040, 391, 560], encoder_prompt=None, encoder_prompt_token_ids=None, prompt_logprobs=None, outputs=[CompletionOutput(index=0, text='\n</thought>\n\n인간의 intelligence를 computer로 구현하는 것.', token_ids=[560, 2240, 52040, 391, 560, 560, 25284, 730, 13887, 4605, 6458, 715, 19495, 1130, 657, 924, 375, 361], routed_experts=None, cumulative_logprob=None, logprobs=None, finish_reason=stop, stop_reason=None)], finished=True, metrics=None, lora_request=None, num_cached_tokens=0)]

그런데 이렇게 진행하는 모델은 내부에 config.json 파일이 있어야 한다. (정확히는 gguf 포맷의 모델은 바로 사용할 수 없다는 것이다)

예를 들어 EXAON은 config.json 파일이 있지만 Bllossom-3B-gguf-Q4_k_M은 없다. 그래서 Bllossom-3B-gguf-Q4_k_M은 vLLM에서 바로 사용할 수 없다. (아래 참고 1~2를 참고한다)

config.json 파일이 없다. (gguf 포맷 모델이므로)

config.json 파일이 없다는 에러가 발생한다.

config.json 파일이 있다.

※ 참고 1

■ Hugging Face에서 (Bllossom-3B-gguf-Q4_K_M) 모델 다운로드하기

hf 명령어를 사용한다. huggingface-cli는 더 이상 사용하지 않는다. 위 과정을 진행했다면 hf(Hugging Face Hub CLI)는 이미 설치되어 있다.

파이썬 가상화 환경을 시작한다.

hf auth login
Paste an access token 옵션을 선택하고 Profile - Settings - Access Tokens에서 생성한 토큰을 붙여넣는다.
로그인이 완료된다.

로그인 확인하기
hf auth whoami

Bllossom-3B-gguf-Q4_K_M 모델 다운로드하기
hf download Bllossom/llama-3.2-Korean-Bllossom-3B-gguf-Q4_K_M
로그인하지 않은 상태에서 다운로드하면 느리게 진행되지만 로그인을 했으므로 빠르게 진행된다.

모델 다운로드 위치
/home/sean/.cache/huggingface/hub/
예) /home/sean/.cache/huggingface/hub/models--Bllossom--llama-3.2-Korean-Bllossom-3B-gguf-Q4

※ 참고 2

Bllossom-3B-gguf-Q4_K_M 같은 gguf 포맷 모델 저장소에는 config.json 파일이 포함되어 있지 않다. guff 파일은 모델의 가중치뿐만 아니라 토크나이저 설정, 레이어 수, 아키텍처 정보 등 config.json에 들어가는 모든 메타데이터를 단일 guff 파일 내부에 바이너리 형태로 통합하여 저장하기 때문이다. 모델의 메타데이터와 아키텍처 구조를 확인하거나 다른 라이브러리와 호환을 맞추기 위해 json 파일이 필요하다면 양자화되기 전 원본 모델 저장소인 Bllossom/llama-3.2-Korean-Bllossom-3B에 있는 config.json 및 토크나이저 설정 파일들을 사용하면 된다. (설정 파일을 직접 다운로드 받아 gguf 파일이 있는곳에 저장할 필요는 없다)

llm = LLM(
        model="/home/sean/.cache/huggingface/hub/models--Bllossom--llama-3.2-Korean-Bllossom-3B-gguf-Q4_K_M/snapshots/c07b7a0f2688d1212612b653a752a0dfe4e18bae/llama-3.2-Korean-Bllossom-3B-gguf-Q4_K_M.gguf",
        # 모델은 저장된 경로와 이름을 정확히 적어준다.
        tokenizer="Bllossom/llama-3.2-Korean-Bllossom-3B",
        # 토크나이저는 저장소 이름을 적어줘도 된다.
        trust_remote_code=True,
        gpu_memory_utilization=0.7,
        dtype="float16",
    )

하지만 위와 같이 LLM 클래스를 생성하면 될 것 같은데, WSL에서 실행하면 계속 UVA 관련 에러가 발생한다. WSL이 아닌 리눅스를 네이티브 운영체제로 사용하는 환경에서 테스트해 봐야 할 것 같다.

또한 vLLM에서 gguf 포맷 모델 사용은 실험적 단계이며 특별한 제약과 조건이 있어 추천하지 않는다. vLLM은 AWQ, GPTQ, FP8 같은 GPU 네이티브 양자화 포맷에서 제대로 된 성능이 나온다. gguf 포맷 모델을 로컬 환경에서 편하고 안정적으로 사용하려면 Ollama를 사용하자.

GGUF(GPT-Generated Unified Format)는 인공지능 모델(특히 LLM)을 개인 PC나 노트북 같은 로컬 환경에서 빠르고 효율적으로 실행하기 위해 설계된 단일 파일 모델 포맷이다.

3B: 모델의 매개변수가 30억 개이다. (3 Billion)

Q4: 4비트 양자화를 의미. 원래 16비트인 모델을 4비트로 압축하여 파일 용량과 메모리를 1/4로 줄였다는 뜻.

K_M: 양자화 기법의 종류. 보통 _L(Large), _M(Medium), _S(Small) 로 나뉘며, Q4_K_M은 성능 저하를 최소화하면서 용량을 줄인 가장 대중적이고 밸런스가 좋은 기법이다.

■ UVA

WSL에서 UVA는 일반적으로 엔비디아(NVIDIA)의 Unified Virtual Addressing(통합 가상 주소) 기술을 의미합니다.
이는 GPU가 컴퓨터 메모리(RAM)와 GPU 자체 메모리를 하나의 주소 공간으로 다룰 수 있게 해주는 기술입니다. WSL 환경에서는 AI/머신러닝(예: PyTorch)을 구동할 때 GPU 가속을 위해 필수적으로 사용되는 핵심 기능입니다.

WSL에서 UVA가 중요한 이유
1. 메모리 접근 단순화: CPU 메모리와 GPU 메모리 간의 데이터를 복사할 때 위치를 일일이 지정할 필요가 없습니다.
2. AI 및 딥러닝 가속: vLLM이나 대형 모델(LLM) 학습 시 VRAM 부족을 해결하기 위해 CPU RAM을 공유해 사용할 때(CPU Offloading), 이 기술이 필수적으로 작동해야 합니다.
3. 호환성 이슈 해결: 종종 WSL 환경에서 이 기능이 제대로 감지되지 않으면 메모리 오류가 발생하거나 가속 기능이 작동하지 않을 수 있습니다.

※ 참고 3

파일 익스플로러 주소창에 \\wsl$를 입력하면 WSL에 설치된 운영체제의 파일에 접근할 수 있다. 물론 왼쪽 패널에 Linux - Ubuntu-24.04로 접근해도 된다.

※ 참고 4

vLLM Documentation

vLLM GitHub

[WPF] Google's Material Design

J-sean — Thu, 18 Jun 2026 17:00:24 +0900

Google's Material Design을 사용해 보자.

MaterialDesignThemes를 설치한다.

코드를 약간 수정해야 한다.

<Application x:Class="Test.App"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:local="clr-namespace:Test"
             StartupUri="MainWindow.xaml">
    <Application.Resources>
         
    </Application.Resources>
</Application>

원래 App.xaml

<Application x:Class="Test.App"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:materialDesign="http://materialdesigninxaml.net/winfx/xaml/themes"
             StartupUri="MainWindow.xaml">
    <Application.Resources>
        <ResourceDictionary>
            <ResourceDictionary.MergedDictionaries>
                <materialDesign:BundledTheme BaseTheme="Light" PrimaryColor="DeepPurple" SecondaryColor="Lime" />
                <ResourceDictionary Source="pack://application:,,,/MaterialDesignThemes.Wpf;component/Themes/MaterialDesign3.Defaults.xaml" />
            </ResourceDictionary.MergedDictionaries>
        </ResourceDictionary>
    </Application.Resources>
</Application>

수정된 App.xaml

<Window x:Class="Test.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:Test"
        mc:Ignorable="d"
        Title="MainWindow" Height="450" Width="800">
    <Grid>

    </Grid>
</Window>

원래 MainWindow.xaml

<Window x:Class="Test.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:Test"
        mc:Ignorable="d"
        Style="{StaticResource MaterialDesignWindow}"
        Title="MainWindow" Height="450" Width="800">
    <Grid>

    </Grid>
</Window>

수정된 MainWindow.xaml (Style 속성만 추가 되었다)

버튼을 하나 추가한다.

버튼의 Properties - Miscellaneous - Style을 클릭하고 Local Resource에서 원하는 스타일을 선택할 수 있다.

Material Design을 설치하고 세팅하기 전에는 Style 항목이 비어 있다. Material Design을 설치하고 세팅했기 때문에 선택할 수 있는 것이다.

MaterialDesignFloatingActionDarkButton을 선택했다.

코드를 빌드하고 실행한다.

※ 참고

Material Design

Getting Started (오른쪽 패널의 Controls, Theming 등도 참고 하자)