Ai ML

1. Discourse
    • 언어/기술: Ruby on Rails + Ember.js
    • 특징: 현대적인 UI, 모바일 친화적, 소셜 네트워크 느낌의 토론 게시판.
    • 장점:
        ◦ 알림, @멘션, 실시간 업데이트 지원
        ◦ 플러그인/테마로 확장성 높음
        ◦ SSO, OAuth, LDAP 등 연동 가능
    • 추천 대상: 최신형 커뮤니티, 기술 포럼, 고객 지원 Q&A 운영하려는 팀.

    • 홈페이지: https://www.discourse.org

    • Git: https://github.com/discourse

2. NodeBB
    • 언어/기술: Node.js + MongoDB/Redis
    • 특징: 빠르고 반응성 좋은 포럼, 실시간 알림 및 WebSocket 기반.
    • 장점:
        ◦ Slack/Discord 같은 느낌의 인터랙션
        ◦ 플러그인 마켓 풍부
        ◦ Docker 설치 지원
    • 추천 대상: 채팅·SNS와 유사한 경험을 원하거나, Node.js 환경에 익숙한 개발팀.
    • 홈페이지: https://nodebb.org

    • Git: https://github.com/NodeBB

3. Flarum
    • 언어/기술: PHP + MySQL
    • 특징: 미니멀하고 빠른 차세대 포럼. “심플한 Discourse” 느낌.
    • 장점:
        ◦ 확장 플러그인 생태계 존재
        ◦ 모바일 대응 우수
        ◦ 설치가 비교적 간단 (PHP 환경이면 OK)
    • 추천 대상: 가볍고 심플한 커뮤니티를 빠르게 구축하려는 소규모 팀/동호회.
    • 홈페이지: https://flarum.org

    • Git: https://github.com/flarum

4. MyBB
    • 언어/기술: PHP + MySQL
    • 특징: 전통적인 게시판 스타일 (네이버 카페·phpBB 같은 느낌).
    • 장점:
        ◦ 오래된 안정적인 프로젝트, 한글화 자료 풍부
        ◦ 플러그인/테마 다양
        ◦ 전통적인 게시판 UI에 익숙한 사용자에게 친숙
    • 추천 대상: 학급/동호회 커뮤니티, 게임 길드 포럼 등 전통적 게시판 선호 시.
    • 홈페이지: https://mybb.com

    • Git: https://github.com/mybb

5. phpBB 
    • 언어/기술: PHP + MySQL/PostgreSQL
    • 특징: 가장 오래된 오픈소스 포럼 중 하나. 커뮤니티 규모가 큼.
    • 장점:
        ◦ 방대한 플러그인/테마
        ◦ 유저 권한 관리가 매우 세밀함
        ◦ 대규모 포럼 운영에 검증된 솔루션
    • 추천 대상: 대형 커뮤니티, 장기간 안정적인 운영이 필요한 경우.
    • 홈페이지: https://www.phpbb.com

    • Git: https://github.com/phpbb

6. Vanilla Forums (오픈소스 버전)
    • 언어/기술: PHP
    • 특징: 현대적인 UI + 소셜 기능. 기업용 상용 버전도 존재.
    • 장점:
        ◦ 깔끔한 인터페이스
        ◦ 기본 기능 충실
        ◦ 커머스·서포트 포럼 운영에도 적합
    • 추천 대상: 기업용 커뮤니티, 고객지원 포럼.

    • 홈페이지: https://open.vanillaforums.com

    • Git: https://github.com/vanilla

   

1. OpenProject
    • 특징: Gantt 차트, 칸반·스크럼 보드, 시간 추적, 이슈 및 문서 관리 등 종합 프로젝트 관리 기능 제공. 모던한 UI와 높은 보안성을 갖춘 온프레미스/클라우드 배포 모두 가능 
    •  장점:
        ◦  사용자 친화적인 디자인과 상세한 온보딩/문서 지원 
        ◦  워크플로우 전반을 하나의 플랫폼에서 관리 가능 
    •  활용 사례: 건설업, 헬스케어 등 민감한 도메인에서도 선호됨 
    •  주의사항: 커뮤니티 에디션의 기능 제한과 다소 높은 학습 곡선 존재 

    •  홈페이지: https://www.openproject.org/

2. Taiga
    •  특징: 스크럼과 칸반 중심의 애자일 방식 프로젝트 관리에 특화된 시스템. 직관적인 UI와 가벼운 구조가 장점 
    •  장점:
        ◦  백로그, 스프린트, 이슈 트래킹 등 애자일 팀에 최적화된 기능 
        ◦  쉬운 설치 및 다양한 언어 지원.
    •  주의사항: 고급 프로젝트 관리 기능이나 복잡한 워크플로우에는 한계 있을 수 있음.
    •  홈페이지: https://taiga.io/

3. Kanboard
    •  특징: 초경량 칸반 보드 기반. 단순하고 효율적인 작업 시각화에 최적화된 도구 
    •  장점:
        ◦  드래그 앤 드롭 UI, 자동화, CLI 등 심플하지만 필요한 기능 제공.
        ◦  도커 환경에서도 쉽게 운영 가능.
    •  주의사항: 기능이 칸반 중심으로 제한적이며 모바일 앱은 없음
    •  홈페이지: https://kanboard.org/

4. Trac
    •  특징: 이슈 추적, 버전 관리(Git/SVN) 통합, 위키와 간단한 로드맵 기능을 제공하는 웹 기반 관리 시스템 
    •  장점:
        ◦ 프로젝트 일정, 티켓, 위키 간 하이퍼링크로 유기적 통합.
        ◦  타임라인, RSS/이메일 알림, 상세 권한 관리 기능 탑재.
    •  활용 사례: Django, FFmpeg, WordPress 등 다양한 오픈소스 프로젝트에서 사용 
    •  주의사항: UI가 다소 전통적이며, 현대적인 인터페이스를 선호하는 경우 아쉬울 수 있음.
    •  홈페이지: https://trac.edgewall.org/

5. ProjeQtOr
    •  특징: '품질 중심 프로젝트 조직(Quality based Project Organizer)'이라는 슬로건으로, 리스크 관리, 예산/비용, 보고서, 워크플로우 기능 등 다양한 기능 제공 
    •  장점:
        ◦  다국어 지원, 멀티 플랫폼.
    •  주의사항: 설정이 다소 복잡할 수 있으며, UI도 전통적일 수 있음.

    •  홈페이지: https://www.projeqtor.org/en/product-en

6. WorkLenz

    •  특징: 오픈소스 워크플로우 관리 도구로, HR 및 CRM 모듈 포함. GitHub에서 꾸준히 활발하게 개발 중

    •  홈페이지: https://worklenz.com/

Grafana에서 주식차트를 그리는 방법을 설명드립니다.

데이터 구조만 맞춰주시고 javascript 코드는 그대로 사용하시면 아래와 같은 그래프가 표시됩니다.

• 차트

• 데이터 구조

• Javascript 코드입니다.

const rawData = [];
context.panel.data.series.forEach((series) => {
  const event_dates_Field = series.fields.find(f => f.name.toLowerCase().includes("event_date"));	// 날짜
  const openingPrices_Field = series.fields.find(f => f.name.toLowerCase().includes("openingprice"));	// 시가
  const tradePrices_Field = series.fields.find(f => f.name.toLowerCase().includes("tradeprice"));	// 종가
  const lowPrices_Field = series.fields.find(f => f.name.toLowerCase().includes("lowprice"));	// 저가
  const highPrices_Field = series.fields.find(f => f.name.toLowerCase().includes("highprice"));	// 고가
  if (!event_dates_Field || !openingPrices_Field || !tradePrices_Field || !lowPrices_Field || !highPrices_Field) return;

  const event_dates = event_dates_Field.values;
  const openingPrices = openingPrices_Field.values;
  const tradePrices = tradePrices_Field.values;
  const lowPrices = lowPrices_Field.values;
  const highPrices = highPrices_Field.values;

  for (let i = 0; i < event_dates.length; i++) {
    rawData.push([
      event_dates.get(i).toString(),
      openingPrices.get(i).toString(),
      tradePrices.get(i).toString(),
      lowPrices.get(i).toString(),
      highPrices.get(i).toString()
    ]);
  }
});
// console.log(rawData);
function calculateMA(dayCount, data) {
  var result = [];
  for (var i = 0, len = data.length; i < len; i++) {
    if (i < dayCount) {
      result.push('-');
      continue;
    }
    var sum = 0;
    for (var j = 0; j < dayCount; j++) {
      sum += +data[i - j][1];
    }
    result.push(sum / dayCount);
  }
  return result;
}
const dates = rawData.map(function (item) {
  return item[0];	// 날짜
});
const values = rawData.map(function (item) {
  return [+item[1], +item[2], +item[3], +item[4]];	// 시가(1), 종가(2), 저가(3), 고가(4)
});

return {
  legend: {
    data: ['日K', 'MA5', 'MA10', 'MA20', 'MA30'],
    inactiveColor: '#777'
  },
  tooltip: {
    trigger: 'axis',
    axisPointer: {
      animation: false,
      type: 'cross',
      lineStyle: {
        color: '#376df4',
        width: 2,
        opacity: 1
      }
    }
  },
  xAxis: {
    type: 'category',
    data: dates,
    axisLine: { lineStyle: { color: '#8392A5' } }
  },
  yAxis: {
    scale: true,
    axisLine: { lineStyle: { color: '#8392A5' } },
    splitLine: { show: false }
  },
  grid: {
    bottom: 80
  },
  dataZoom: [
    {
      textStyle: {
        color: '#8392A5'
      },
      handleIcon:
        'path://M10.7,11.9v-1.3H9.3v1.3c-4.9,0.3-8.8,4.4-8.8,9.4c0,5,3.9,9.1,8.8,9.4v1.3h1.3v-1.3c4.9-0.3,8.8-4.4,8.8-9.4C19.5,16.3,15.6,12.2,10.7,11.9z M13.3,24.4H6.7V23h6.6V24.4z M13.3,19.6H6.7v-1.4h6.6V19.6z',
      dataBackground: {
        areaStyle: {
          color: '#8392A5'
        },
        lineStyle: {
          opacity: 0.8,
          color: '#8392A5'
        }
      },
      brushSelect: true
    },
    {
      type: 'inside'
    }
  ],
  series: [
    {
      type: 'candlestick',
      name: 'Day',
      data: values,
      itemStyle: {
        color: '#FD1050',
        color0: '#0CF49B',
        borderColor: '#FD1050',
        borderColor0: '#0CF49B'
      }
    },
    {
      name: 'MA5',
      type: 'line',
      data: calculateMA(5, values),
      smooth: true,
      showSymbol: false,
      lineStyle: {
        width: 1
      }
    },
    {
      name: 'MA10',
      type: 'line',
      data: calculateMA(10, values),
      smooth: true,
      showSymbol: false,
      lineStyle: {
        width: 1
      }
    },
    {
      name: 'MA20',
      type: 'line',
      data: calculateMA(20, values),
      smooth: true,
      showSymbol: false,
      lineStyle: {
        width: 1
      }
    },
    {
      name: 'MA30',
      type: 'line',
      data: calculateMA(30, values),
      smooth: true,
      showSymbol: false,
      lineStyle: {
        width: 1
      }
    }
  ]
};

사실 dbt는 정식 명칭이 “data build tool”인데, dbt Labs에서는 일부러 소문자 표기(db t)를 고수합니다.

이유 

1. 브랜딩 철학

• dbt Labs는 “데이터팀을 위한 도구가 거창한 이름이 아니라, 가볍고 실용적인 툴”이라는 이미지를 주고 싶었습니다.
• 그래서 일반적인 약자처럼 “DBT”라고 대문자로 쓰지 않고, 소문자 dbt라는 독특한 스타일을 선택했습니다.

2. 개발자 문화와 유사성

• 리눅스 명령어나 Python 패키지 이름처럼, 소문자 CLI(command-line interface) 툴 스타일을 따랐습니다.
• 실제로 설치 후 실행할 때도 dbt run, dbt test처럼 소문자 명령어를 입력합니다.

3. 공식 가이드라인

• dbt Labs 공식 문서에서도 “항상 dbt라고 소문자로 작성할 것”을 권장합니다. 가이드

• 대문자 DBT는 다른 의미(예: 심리치료에서 쓰이는 Dialectical Behavior Therapy)와 혼동될 수 있기 때문에 차별화 목적도 있습니다.

• ETL ( Extract → Transform → Load )
  • 전통적 방식
  • 데이터를 원본에서 추출(Extract) → 중간 처리 서버에서 변환(Transform) → 최종적으로 데이터 웨어하우스에 적재(Load)
  • 데이터 웨어하우스의 연산 능력이 부족하던 시절에 주로 사용됨
  • [Source] → (Extract) → [ETL 서버에서 Transform] → (Load) → [Data Warehouse]
• ELT ( Extract → Load → Transform )
  • 현대적 방식 (dbt가 여기에 해당)
  • 데이터를 원본에서 추출(Extract) → 그대로 데이터 웨어하우스에 적재(Load) → 웨어하우스 내부에서 SQL 기반 변환(Transform) 수행
  • Snowflake, BigQuery, Redshift, Databricks 등 강력한 클라우드 DWH가 등장하면서 표준이 됨
  • [Source] → (Extract + Load, Ingestion) → [Data Warehouse] → (Transform, dbt) → [Analytics-ready Data]
• 요약

주가 데이터 와 이동평균을 Grafana의 차트에 표시해주기위환 MySQL 쿼리 입니다.

일 배치로 이동평균을 계산해 놓을수 도 있지만 좁은 기간의 데이터 조회가 빈번할 때는

쿼리에서 이동평균을 계산해도 괜찮을 것 같아 쿼리를 제작하였습니다.

이동평균을 주가 뿐만 아니라 DAU등에 접목해도 좋을 것 같습니다.

✅ 데이터 구조

✅ 쿼리

set @symbol_code = '035420';    -- 종목 코드
set @interval_day = 100;        -- 현재일 기준 조회 기간
with sub as (
    select event_date, tradePrice, day_5_moving_avg, day_10_moving_avg, day_20_moving_avg, day_60_moving_avg
    from (
        SELECT event_date, symbol_code, tradePrice
            , ROUND(AVG(tradePrice)OVER (ORDER BY event_date ROWS BETWEEN 4 PRECEDING AND CURRENT ROW), 2) AS day_5_moving_avg  -- 5일 이동 평균
            , ROUND(AVG(tradePrice)OVER (ORDER BY event_date ROWS BETWEEN 9 PRECEDING AND CURRENT ROW), 2) AS day_10_moving_avg  -- 10일 이동 평균
            , ROUND(AVG(tradePrice)OVER (ORDER BY event_date ROWS BETWEEN 19 PRECEDING AND CURRENT ROW), 2) AS day_20_moving_avg  -- 20일 이동 평균
            , ROUND(AVG(tradePrice)OVER (ORDER BY event_date ROWS BETWEEN 59 PRECEDING AND CURRENT ROW), 2) AS day_60_moving_avg  -- 60일 이동 평균
        FROM tbl_stock_list_kor
        WHERE event_date >= date_add(current_date, interval (abs(@interval_day) + 100) * -1 day)
            and event_date <= current_date
            and symbol_code = @symbol_code
    ) as ta
    where event_date >= date_add(current_date, interval abs(@interval_day) * -1 day) and event_date <= current_date
)
select cast(ta.event_date as char(10)) as event_date
    , (case tb.rno when 1 then '주가'
                when 2 then '5일선'
                when 3 then '10일선'
                when 4 then '20일선'
                when 5 then '60일선'
                end) as legend
, (case tb.rno when 1 then ta.tradePrice
                when 2 then ta.day_5_moving_avg
                when 3 then ta.day_10_moving_avg
                when 4 then ta.day_20_moving_avg
                when 5 then ta.day_60_moving_avg
                end) as price
from sub as ta
cross join (select 1 rno union select 2 union select 3 union select 4 union select 5) as tb
order by event_date asc, legend asc;

✅ 쿼리 실행 결과

✅ Chart

> DAU 데이터 구조

> DAU 및 Z-Score 조회 쿼리

SELECT
    event_date,
    dau,
    ROUND((dau - stats.avg_dau) / stats.std_dau, 4) AS dau_zscore
FROM
    tbl_dau as ta,
    (
        SELECT
            AVG(dau) AS avg_dau,
            STDDEV(dau) AS std_dau
        FROM tbl_dau
        where event_date >= '2025-07-01'
            and event_date < '2025-07-11'
    ) AS stats
where ta.event_date >= '2025-07-01'
    and ta.event_date < '2025-07-11'
ORDER BY event_date;

> 조회 결과

> 분류( Classification ) 모델 평가 지표

> 회귀 (Regression) 모델 평가 지표

> 클러스터링 (Clustering) 평가 지표

Grafana에서 Business Chart를 사용해서 누적형 그래프를 그리는 방법을 설명하겠습니다.

• 데이터 구조

• 그래프

• Script 코드

const dataMap = {}; 							// 시즌별 데이터 저장용
const xLabelsSet = new Set(); 	// x축 레벨 값들
let minYValue = Infinity;      			// y축 최소값 계산용

context.panel.data.series.forEach((series) => {
  const legendField = series.fields.find(f => f.name.toLowerCase().includes("legend"));		// 범례
  const xvalueField = series.fields.find(f => f.name.toLowerCase().includes("xvalue"));			// x축에 표시할 값
  const yvalueField = series.fields.find(f => f.name.toLowerCase().includes("yvalue"));			// y축에 표시할 값
  if (!legendField || !xvalueField || !yvalueField) return;

  const legends = legendField.values;		// 범례 배열
  const xvalues = xvalueField.values;		// x축 값 배열
  const values = yvalueField.values;			// y축 값 배열

  for (let i = 0; i < legends.length; i++) {
    const legend = legends.get(i);
    const xvalue = xvalues.get(i);
    const yvalue = values.get(i);
    xLabelsSet.add(xvalue);

    if (!dataMap[legend]) {
      dataMap[legend] = {};
    }
    dataMap[legend][xvalue] = yvalue;

    // 최소값 갱신
    if (typeof yvalue === 'number' && yvalue < minYValue) {
      minYValue = yvalue;
    }
  }
});

// x축 정렬된 레벨 값들 (문자열 기준 정렬)
const xLabels = Array.from(xLabelsSet).sort((a, b) => a - b);

// 시리즈 생성
const series = Object.keys(dataMap).map(legend => {
  const xValueMap = dataMap[legend];
  const displayData = xLabels.map(xvalue => xValueMap[xvalue] ?? null);
  // 최고값 찾기
  let maxIndex = -1;
  let maxValue = -Infinity;
  displayData.forEach((v, i) => {
    if (typeof v === 'number' && v > maxValue) {
      maxValue = v;
      maxIndex = i;
    }
  });

  return {
    name: legend,
    type: "line",
    stack: "total",
    data: displayData,
    symbolSize: 4,    // 점의 크기
    areaStyle: {
      opacity: 0.3    // 투명도 조절 (0 ~ 1 사이 값)
    },
  };
});

return {
  grid: {
    bottom: "4.5%",
    containLabel: true,
    left: "3%",
    right: "4%"
  },
  tooltip: {
    trigger: "item",
    axisPointer: {
      type: 'cross',
    },
    formatter: function (params) {
      // 숫자 포맷: 천단위 구분
      const value = typeof params.data === 'number'
        ? params.data.toLocaleString('ko-KR')
        : params.data;
      return `
        ${params.marker}
        <strong style="color:${params.color}">${params.seriesName}</strong>: ${value}
      `;
    }
  },
  legend: {
    name: '시즌',
    data: Object.keys(dataMap)
  },
  xAxis: {  // x축 설정
    name: '',           // 축 이름 텍스트.
    nameLocation: "middle", // "start", "middle", "end" 가능. 이름의 위치 지정.
    nameGap: 25,            // 축 이름과 축 간의 거리(px)
    nameTextStyle: {        // 폰트 크기, 두께 등 스타일 설정
      fontSize: 14,
      fontWeight: 'bold'
    },
    boundaryGap: false,
    type: "category",
    data: xLabels, 
    axisLabel: {
      margin: 25,       // 레이블과 축 간 거리
      fontSize: 13      // ← 글씨 크기 설정 (예: 12px)
    }
  },
  yAxis: {  // y축 설정
    name: '',
    nameTextStyle: {
      fontSize: 14,
      fontWeight: 'bold'
    },
    type: "value",
    min: (minYValue * 0.85).toFixed(0)
  },
  series
};

Grafana에서 Business Charts를 사용할 때 Tooltip에 표시되는 내용을 정렬하는 방법을 설명드리겠습니다.

• 적용 전 / 후의 모습입니다.

• tooltip 옵션의 코드를 아래와 같이 수정합니다.

tooltip: {
  trigger: "axis",
  formatter: function (params) {
    // 수치를 천 단위로 변환하는 함수
    const formatNumber = num => {
      if (num == null || isNaN(num)) return '-';
      return num.toLocaleString();  // 또는: String(num).replace(/\B(?=(\d{3})+(?!\d))/g, ",")
    };

    const sortedParams = params.slice().sort((a, b) => {
      const aVal = a.data != null ? a.data : -Infinity;
      const bVal = b.data != null ? b.data : -Infinity;
      return bVal - aVal;
    });

    let text = `${params[0].axisValue}<br/>`;
    sortedParams.forEach(param => {
      text += `
        <span style="display:inline-block;margin-right:5px;border-radius:10px;width:9px;height:9px;background-color:${param.color};"></span>
        ${param.seriesName}: ${formatNumber(param.data)}<br/>
      `;
    });
    return text;
  }
}

Grafana에서 서드파티 차트중 Business Charts를 사용하는 방법을 알려드리겠습니다.

2. 아래 JavaScript 코드를 Visual Editor 탭의 Function에 붙여넣어 줍니다.

    코드에 대한 설명은 주석을 참고하시거나 ChatGPT에 코드를 붙여넣은 후 프로프트로 코드 수정을 질문하시면 꽤 정확한 답변을 얻으실 수 있습니다.

const dataMap = {}; 					  // 전체 데이터
const xLabelsSet = new Set(); 	// X축 라벨값 집합

// 데이터 집합을 생성합니다.
context.panel.data.series.forEach((series) => {
  const legendField = series.fields.find(f => f.name.toLowerCase().includes("legend"));		// 범례
  const xValueField = series.fields.find(f => f.name.toLowerCase().includes("xvalue"));		//  X 축
  const yValueField = series.fields.find(f => f.name.toLowerCase().includes("yvalue"));		// Y 축
  if (!legendField || !xValueField || !yValueField) return;

  const legends = legendField.values;
  const xValues = xValueField.values;
  const yValues = yValueField.values;

  for (let i = 0; i < legends.length; i++) {
    const legend = legends.get(i);
    const xValue = xValues.get(i);
    const yValue = yValues.get(i);
    xLabelsSet.add(xValue);
    if (!dataMap[legend]) {
      dataMap[legend] = {};
    }
    dataMap[legend][xValue] = yValue;
  }
});

// X축에 표시할 Unique 라벨 배열
const xLabels = Array.from(xLabelsSet).sort((a, b) => a - b);
// 시리즈 생성
const series = Object.keys(dataMap).map(legend => {
  const xValueMap = dataMap[legend];
  const yValueMap = xLabels.map(xValue => xValueMap[xValue] ?? null);
  return {
    name: legend,     // 범례에 속한 항목 이름
    type: "line",     // 차트 타입(bar, line)
    stack: "",
    data: yValueMap   // Y Value 데이터 배열
  };
});

return {
  grid: {
    top: "30%",
    bottom: "5%",  // 그래프 하단의 여백을 설정하는 효과가 있습니다.
    containLabel: true,
    left: "3%",
    right: "4%"
  },
  tooltip: {
    trigger: "axis"
  },
  legend: { // 범례 설정
    type: 'plain', // plain, scroll
    name: '모델',
    data: Object.keys(dataMap),
    orient: 'horizontal',      // 수평 정렬
    top: 'top',
    left: 'center',
    itemGap: 10,               // 범례 항목 간 간격
    padding: [10, 20],         // 범례 영역 안쪽 여백
    width: '80%',              // 너비 제한을 주면 줄바꿈 발생 가능
    textStyle: {
      fontSize: 14
    }
  },
  xAxis: {  // x축 설정
    name: '',           // 축 이름 텍스트.
    nameLocation: "middle", // "start", "middle", "end" 가능. 이름의 위치 지정.
    nameGap: 30,            // 축 이름과 축 간의 거리(px)
    nameTextStyle: {        // 폰트 크기, 두께 등 스타일 설정
      fontSize: 20,
      fontWeight: 'bold'
    },
    boundaryGap: true,
    type: "category",
    data: xLabels,
    axisLabel: {
      fontSize: 14,
      rotate: 60,  // 라벨을 45도 기울임
      interval: 0 // 모든 항목 출력 (스크롤 지원에 필수)
    }
  },
  yAxis: {  // y축 설정
    name: '판매량',
    nameTextStyle: {
      fontSize: 14,
      fontWeight: 'bold'
    },
    type: "value",
    interval: 100000  // 10 단위 간격 설정
  },
  series,
  dataZoom: [
    {
      type: 'slider',
      show: true,
      xAxisIndex: 0,
      start: 0,
      end: xLabels.length > 20 ? 50 : 100
    }
  ],
  graphic: [
    {
      type: 'text',
      left: 'left',
      bottom: '20',   // 'bottom'은 grid 바깥 기준이므로, 그래프 아래 적당한 픽셀 위치로 설정
      left: '70',   // 좌측 여백을 설정합니다.
    }
  ]
};

3. 그래프의 출력 결과는 아래와 같습니다.

빌드 도구들에 대해서 간략하게 비교/설명하겠습니다.

• 오픈 소스 빌드 도구
• DSL(Domain Specific Language) 기반 빌드 스크립트 사용: Groovy 또는 Kotlin
• 의존성 관리, 멀티 프로젝트 지원, 캐싱, 병렬 처리 등 고급 기능 제공
• Android Studio의 공식 빌드 시스템

🔁 다른 빌드 도구와의 비교

💡 Gradle의 장점

• 속도: 증분 빌드, 데몬 프로세스, 병렬 빌드 등으로 빠름
• 확장성: 플러그인을 쉽게 추가 가능 (application, java, android 등)
• 유연한 빌드 스크립트: Groovy 또는 Kotlin을 활용하여 복잡한 로직도 작성 가능
• IDE 통합성: IntelliJ, Android Studio 등과 완벽한 통합

📂 예시 (Gradle build.gradle 파일 - Groovy)

plugins {
    id 'java'
}

group = 'com.example'
version = '1.0'

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter'
    testImplementation 'junit:junit:4.13.2'
}

🤔 언제 Gradle을 선택해야 할까?

• Android 개발을 한다면 무조건 Gradle
• 복잡한 멀티 모듈 프로젝트가 있다면 Gradle이 더 유리
• 유연한 빌드 로직이 필요할 때 Gradle 추천
• 단순하고 정적인 빌드 구조를 원한다면 Maven도 괜찮음

1. Adminer (가볍고 간편한 PHP 기반)

• 특징: 단일 adminer.php 파일로 구성된 초경량 SQL 관리 도구
• 지원 DB: MySQL, PostgreSQL, SQLite, MS SQL 등
• 설치: PHP + 웹서버(IIS 또는 Apache)만 있으면 바로 사용 가능
• 장점: 매우 빠르고 간단, 보안 업데이트 잘됨

👉 공식 사이트: https://www.adminer.org/

설치 예시:

1. PHP 설치 (윈도우용 XAMPP, WampServer 또는 IIS + PHP)
2. 웹 루트에 adminer.php 파일 복사
3. 브라우저에서 접속 → DB 로그인 → 쿼리 실행 가능

2. phpMyAdmin (전통적인 웹기반 MySQL 관리자)

• 특징: 가장 널리 쓰이는 MySQL 웹 인터페이스
• 지원 기능: 쿼리 실행, 테이블 관리, import/export, 권한 설정 등
• 설치: PHP + MySQL 환경 필요 (XAMPP, WampServer 등으로 가능)
• 장점: 풍부한 기능, 다국어 지원, 사용자 계정 관리

👉 공식 사이트: https://www.phpmyadmin.net/

3. SQLPad (Node.js 기반의 쿼리 에디터)

• 특징: 웹 기반 SQL 에디터, 쿼리 저장, 시각화도 가능
• 설치: Node.js 필요
• 지원 DB: MySQL, PostgreSQL, SQLite, MSSQL, Presto 등
• 장점: 팀 단위 쿼리 저장, 쿼리 공유 등 협업에 유리

👉 GitHub: https://github.com/sqlpad/sqlpad

🔄 비교 요약

• ⭐PyTorch / TensorFlow
  ◦ 용도: 모델 훈련, 미분 계산, 텐서 연산
  ◦ [PyTorch]
      • 직관적이고 디버깅이 쉬워 LLM 연구와 실험에 널리 사용됨
      •  Hugging Face와의 연동도 뛰어남
  ◦ [TensorFlow]
      •   구글 생태계(GCP, TFX 등)와 잘 통합되며, 대규모 배포에 적합
      •   최근에는 PyTorch보다 덜 사용됨

• Hugging Face ⭐Transformers
  ◦  용도: 사전학습된 LLM 모델 불러오기, fine-tuning, inference
      •  사전학습된 모델 (GPT, BERT, T5, LLaMA 등)을 쉽게 사용할 수 있게 해주는 라이브러리
      •  학습/추론에 필요한 tokenizer, 모델 구조, config 등을 자동으로 관리
      •  텍스트 생성, 분류, QA, 요약 등 다양한 작업에 최적화된 pipeline 제공

from transformers import AutoModelForCausalLM, AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("gpt2")
model = AutoModelForCausalLM.from_pretrained("gpt2")

inputs = tokenizer("Hello, my name is", return_tensors="pt")
outputs = model.generate(**inputs)
print(tokenizer.decode(outputs[0]))

• Datasets (Hugging Face Datasets)
  ◦ 용도: 대규모 데이터셋 로딩, 전처리, 분할
      •   데이터셋을 빠르고 효율적으로 불러오고 사용할 수 있도록 지원
      •   대용량 파일도 메모리에 무리 없이 스트리밍 처리 가능
  ◦  Hugging Face Hub에서 바로 불러올 수 있음

from datasets import load_dataset

dataset = load_dataset("wikitext", "wikitext-2-raw-v1")
print(dataset["train"][0])

• Accelerate / DeepSpeed / bitsandbytes
  ◦ 용도: 대규모 모델 훈련 시 하드웨어 최적화, 메모리 절약
      •    Accelerate: 다양한 하드웨어(CPU, GPU, TPU)에 맞게 모델 학습 코드 자동 조정
      •    DeepSpeed: 마이크로소프트에서 만든 초대형 모델 훈련 최적화 툴
      •    bitsandbytes: 8bit/4bit 양자화 학습 및 추론 지원 → 적은 메모리로 대형 모델 사용 가능
  
  
• PEFT (Parameter-Efficient Fine-Tuning)
  ◦  용도: LLM을 빠르고 저렴하게 파인튜닝 (LoRA, Prefix Tuning 등)
      •    기존 LLM 전체가 아닌 일부 파라미터만 훈련해서 훨씬 적은 자원으로 fine-tuning 가능
      •    대표 기법: LoRA (Low-Rank Adaptation)

from peft import LoraConfig, get_peft_model

• ⭐Tokenizers
  ◦  용도: LLM에 입력될 텍스트를 토큰 단위로 인코딩
      •    Hugging Face의 tokenizers는 빠르고 확장성 높은 토크나이저
      •    Byte-Pair Encoding (BPE), WordPiece, SentencePiece 등 다양한 방식 지원
  
  
• ⭐LangChain / ⭐LlamaIndex
  ◦  용도: LLM 응용 프로그램 구축 (질의 응답, RAG, 에이전트 등)
      •    LangChain: 다양한 LLM, 데이터 소스, 도구를 연결해 에이전트처럼 동작하게 함
      •    LlamaIndex: 사용자 문서를 LLM에 연결해 QA 시스템 구축에 유용 (RAG)
  
  
• WandB / TensorBoard
  ◦  용도: 모델 학습 과정 모니터링, 로그 기록, 하이퍼파라미터 튜닝
      •    실험 추적 및 시각화를 위한 필수 툴
      •    학습 정확도, 손실값, GPU 메모리 사용량 등 확인 가능
  
  
• 부가적으로 알아두면 좋은 라이브러리

• 꼭 알아야 할 핵심 세트

LlamaIndex는 **언어 모델(LLM)**과 **외부 데이터(문서, DB 등)**를 연결해주는 데이터 프레임워크입니다.

• LlamaIndex = LLM + 외부 데이터 연결을 쉽게 만들어주는 도구

LLM은 자체적으로 인터넷이나 PDF, 데이터베이스 같은 구조화되지 않은 데이터에 접근할 수 없습니다. LlamaIndex는 이런 데이터들을 정리하고 쪼개고 인덱싱해서, LLM이 쉽게 "질문-답변", "요약", "검색 기반 생성(RAG)" 등을 할 수 있게 도와주는 라이브러리입니다.

• LlamaIndex가 할 수 있는 작업

    ◦ 문서 로딩 : PDF, Word, HTML, Notion, Airtable 등 다양한 형식의 문서를 읽어옴

    ◦ Chunking : 문서를 적절한 크기로 나눔 (LLM이 다루기 쉽게)

    ◦ Embedding + Indexing : 문서를 벡터화하고 검색 가능한 인덱스를 만듦

    ◦ Query Engine : 사용자 질문을 받아서 적절한 문서 찾고 답변 생성

• 주요 예시

from llama_index import VectorStoreIndex, SimpleDirectoryReader

# 문서 로딩
documents = SimpleDirectoryReader("data/").load_data()

# 인덱스 생성 (벡터화 포함)
index = VectorStoreIndex.from_documents(documents)

# 질의 엔진 생성
query_engine = index.as_query_engine()

# 질의
response = query_engine.query("이 회사의 수익 모델은 무엇인가요?")
print(response)

• 핵심 구성 요소

    ◦ Document : 원본 텍스트 데이터
    ◦ Node : 문서에서 쪼갠 텍스트 블록 (보통 하나의 파라그래프 단위)
    ◦ Index : 벡터 기반 검색 인덱스 (FAISS, Chroma 등 지원)
    ◦ Query Engine : 질의 → 검색 → 응답 생성 파이프라인
    ◦ Retriever : 관련 문서를 찾는 부분
    ◦ Response Synthesizer : 관련 문서들을 종합해서 답변 생성

• 사용 목적

    ◦ 내 회사 문서를 기반으로 GPT 질의 응답
    ◦ PDF 논문 요약
    ◦ SQLite, Notion, Airtable 등 다양한 데이터 연결
    ◦ RAG (Retrieval-Augmented Generation)

• 기본적으로, Regression analysis (회귀 분석)은 몇 개의 독립변수 (예 : 배경음악)를 처리하는 과정이 반드시 필요하며, 그 이유는 독립변수가 종속변수 (예 : 가게에 머무는 시간)에 어떤 영향을 끼치는 지 알아보고자 하기 때문입니다.
  이는 독립변수가 변화함에 따라서, 종속변수 값이 어떻게 변화하는지를 묘사합니다.
• 회귀분석은 몸무게, 속도, 또는 나이와 같은 연속 수치 값으로 분석했을 때 최상의 결과를 도출해낼 수 있습니다.
• 일반 적인 회귀 분석의 활용
  • 고객 만족도와 고객 충성도와의 관계를 도출할 수 있음.
  • 이웃 주민과 그 규모가 주택 가격에 어떤 영향을 주는지를 확인할 수 있음
  • 점포와 역 사이의 거리가 멀면 멀수록 매출이 오르는지 내리는지 혹은 별다른 관계가 없는지
    오른다면 대충 얼마 정도가 오르는지를 알아내어 수익 향상법을 찾아낼 수 있음
• FPS 게임에서의 회귀분석 활용 사례
  1. 플레이어 행동 예측
     • 회귀 분석을 사용하여 특정 플레이어 행동(예: 이동 패턴, 슈팅 정확도, 명중률 등)을 예측할 수 있습니다. 이를 통해 플레이어의 행동을 이해하고, 게임 디자인 또는 AI 개발에 활용할 수 있습니다.
  2. 게임 밸런스 조정
     • 회귀 분석을 사용하여 게임의 밸런스를 평가하고 조정할 수 있습니다. 예를 들어, 특정 무기나 아이템의 사용 빈도와 승률 간의 관계를 조사하여 게임의 균형을 개선하는 데 도움이 될 수 있습니다.
  3. 플레이어 리텐션 분석
     • 회귀 분석을 사용하여 특정 이벤트 또는 게임 요소와 플레이어 리텐션 간의 관계를 조사할 수 있습니다. 이를 통해 어떤 요소가 플레이어를 유지하거나 이탈시키는지 이해하고, 이를 개선하는 방안을 모색할 수 있습니다.
  4. 매치메이킹 및 승률 예측
     • 회귀 분석을 사용하여 특정 매치 조합이나 팀 구성과 승률 간의 관계를 분석할 수 있습니다. 이를 통해 매치메이킹 시스템을 개선하거나 플레이어에게 더 공평한 경기를 제공할 수 있습니다.
  5. 경제 시스템 분석
     • 게임 내 경제 시스템과 관련된 데이터를 회귀 분석하여 아이템 가격 조정이나 경제 균형을 조절하는 데 도움을 줄 수 있습니다.
• 주식 시장에 회귀분석 활용 사례
  1. 블랙 스완 이벤트 탐지
     • 시장 폭락(crash)이나 급등(rally)과 같은 극단적인 가격 변동 감지
     • 경제 위기(예: 2008년 금융위기) 또는 특정 산업의 붕괴 예측
     • 특정 기업의 파산 가능성 조기 경고
       
  2. 이상거래 탐지
     • 비정상적인 거래량 급증 또는 대량 매수/매도 탐지
     • 특정 계좌에서 반복적으로 발생하는 이상 거래 패턴 분석
     • 내부자 거래 및 시장 조작 가능성 탐지
  3. 저평가 종목 발굴
     • 시장에서 과소평가된 희귀한 기회 탐색
     • 특정 조건에서만 나타나는 비정상적인 수익률 패턴 감지
     • 벤치마크 대비 이례적으로 낮은 변동성을 보이는 종목 식별
  4. 고수익 투자전략 개발
     • 고빈도 트레이딩(HFT)에서 특정 희귀 이벤트를 활용한 전략
     • 옵션 시장에서 극단적인 변동성을 이용한 투자 기법
     • 특정 마켓 메이커의 유동성 공급 패턴 분석
  5. 뉴스 및 소셜 미디어 분석
     • 특정 종목 또는 산업에 대한 희귀한 키워드 감지하여 가격 변동 예측
     • 감성 분석(Sentiment Analysis)을 통한 극단적인 시장 반응 탐지
     • 주요 CEO의 발언이나 기업 공시 중 비정상적인 정보 변화 탐지

🔹 ACME(Automated Certificate Management Environment)란?

ACME(Automated Certificate Management Environment)는 SSL/TLS 인증서를 자동으로 발급, 갱신, 폐기할 수 있도록 설계된 프로토콜입니다.

Let's Encrypt에서 처음 개발했지만, 이제는 다른 CA(Certificate Authority, 인증 기관)에서도 지원하고 있어. 대표적으로 Let's Encrypt, ZeroSSL, Buypass 등이 ACME를 사용해서 SSL 인증서를 자동화할 수 있도록 제공합니다.

🔹 ACME의 주요 기능

✅ 인증서 자동 발급
✅ 도메인 소유권 검증(DNS, HTTP 등)
✅ 자동 갱신 (SSL 인증서가 만료되기 전에 자동으로 갱신 가능)
✅ 인증서 폐기 및 취소 지원

🔹 ACME 작동 방식 (간단한 과정)

1. 클라이언트가 인증서 요청
   • ACME 클라이언트(예: Certbot)가 CA(인증 기관) 서버에 SSL 인증서를 요청함.
2. 도메인 소유권 검증
   • CA는 요청한 도메인이 실제로 사용자의 것인지 확인하기 위해 검증을 수행함.
   • 검증 방식: HTTP 파일 인증, DNS TXT 레코드 인증 등이 있음.
3. SSL 인증서 발급
   • 도메인 소유권이 확인되면 CA가 SSL 인증서를 발급해줌.
4. 자동 갱신
   • 일정 기간(예: 90일)이 지나면 ACME 클라이언트가 자동으로 인증서를 갱신함.

🔹 ACME를 지원하는 주요 클라이언트(도구)

클라이언트특징

🔹 ACME를 활용한 SSL 발급 예제 (Certbot 사용)

🔧 Let's Encrypt에서 무료 SSL 인증서 발급 (Nginx 기준)

sudo apt install certbot python3-certbot-nginx
sudo certbot --nginx -d yourdomain.com -d www.yourdomain.com

이 명령어를 실행하면 ACME 프로토콜을 사용하여 자동으로 도메인 소유권을 확인하고 SSL 인증서를 설치해 주어야 함.

🔹 결론

• ACME는 SSL 인증서를 자동으로 발급 및 갱신하는 프로토콜.
• Let's Encrypt, ZeroSSL, Buypass 같은 무료 SSL 제공 업체에서 사용됨.
• Certbot, acme.sh(acme.sh-github) 같은 클라이언트를 사용하면 쉽게 설정 가능.

자동 SSL 인증서를 설정하려고 한다면, 사용 중인 웹 서버(Apache, Nginx)나 환경을 알려주면 더 자세히 도와줄 수 있습니다.

🔹 1. Let's Encrypt (가장 많이 사용됨)

✅ 특징:

• 무료로 90일 동안 유효한 SSL 인증서 제공
• 자동 갱신 가능 (Certbot 사용)
• 대부분의 웹 서버(Apache, Nginx 등)와 호환됨

🔧 발급 방법 (Certbot 사용):

1. Certbot 설치

sudo apt update && sudo apt install certbot python3-certbot-nginx

2. SSL 인증서 발급 (Nginx 기준)

sudo certbot --nginx -d yourdomain.com -d www.yourdomain.com

3. 자동 갱신 설정

sudo certbot renew --dry-run

4. 웹 서버 재시작

sudo systemctl restart nginx

🔹 2. ZeroSSL

✅ 특징:

• 90일 무료 SSL 인증서 제공 (3개월마다 갱신 필요)
• 발급 과정이 GUI 기반이라 초보자도 쉽게 사용 가능
• ACME 프로토콜 지원 (Certbot과 유사하게 자동 갱신 가능)

🔧 발급 방법:

1. ZeroSSL 공식 사이트에 접속하여 회원가입
2. "New Certificate" 클릭 후 도메인 입력
3. 인증 방법 선택 (DNS, HTTP 파일 업로드 등)
4. SSL 인증서 다운로드 및 서버에 적용
5. 갱신이 필요할 때 같은 과정 반복 (자동 갱신을 원하면 ACME 사용)

🔹 3. Cloudflare SSL

✅ 특징:

• 무료 플랜에서도 SSL 지원 (유효기간 무제한)
• Cloudflare CDN과 함께 사용 가능
• 서버에 직접 인증서를 설치하지 않아도 됨 (클라우드 기반)

🔧 발급 방법:

1. Cloudflare 가입 후 사이트 추가
2. 네임서버를 Cloudflare로 변경 (도메인 업체에서 설정)
3. "SSL/TLS" 설정에서 "Flexible" 또는 "Full" 선택
4. Cloudflare를 통해 HTTPS 적용 완료

🔹 4. Buypass Go SSL

✅ 특징:

• 180일(6개월)짜리 무료 SSL 인증서 제공
• ACME 클라이언트를 사용하여 자동 발급 가능
• Let's Encrypt와 유사한 방식

🔧 발급 방법:

1. ACME 클라이언트(Certbot 등)를 사용하여 SSL 신청
2. 다음 명령어 실행 (Nginx 기준)

sudo certbot --server "https://api.buypass.com/acme/directory" -d yourdomain.com

   3.  발급된 인증서를 서버에 적용

🔹 비교 요약

서비스유효기간자동 갱신주요 특징

아래 코드는 Hugging Face의 transformers, peft를 사용하여 GPT-2 모델을 LoRA로 미세 조정하는 예제입니다.

✅ 필요한 패키지 설치

먼저 필요한 라이브러리를 설치합니다.

pip install torch transformers datasets peft accelerate

📌 Python 코드: LoRA를 이용한 GPT-2 미세 조정

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments, Trainer
from peft import LoraConfig, get_peft_model
from datasets import load_dataset

# 1️⃣ 모델 및 토크나이저 불러오기
model_name = "gpt2"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)

# 2️⃣ LoRA 설정
lora_config = LoraConfig(
    r=8,  # LoRA 랭크 (낮을수록 연산량 감소)
    lora_alpha=16,  # LoRA 스케일링 계수
    target_modules=["c_attn", "c_proj"],  # 적용할 모델의 특정 레이어
    lora_dropout=0.1,  # 드롭아웃 비율
    bias="none",
)

# 3️⃣ LoRA 적용
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()  # 학습 가능한 파라미터 확인

# 4️⃣ 데이터셋 로드 및 전처리 (예제: Hugging Face "wikitext" 데이터)
dataset = load_dataset("wikitext", "wikitext-2-raw-v1", split="train")

def tokenize_function(examples):
    return tokenizer(examples["text"], padding="max_length", truncation=True)

tokenized_datasets = dataset.map(tokenize_function, batched=True)
tokenized_datasets = tokenized_datasets.shuffle().select(range(1000))  # 데이터 샘플링

# 5️⃣ 학습 설정
training_args = TrainingArguments(
    output_dir="./lora-gpt2-model",
    evaluation_strategy="epoch",
    save_strategy="epoch",
    learning_rate=5e-4,
    per_device_train_batch_size=8,
    per_device_eval_batch_size=8,
    num_train_epochs=3,
    weight_decay=0.01,
    logging_dir="./logs",
)

# 6️⃣ Trainer 객체 생성 및 학습 시작
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_datasets,
)

trainer.train()

# 7️⃣ LoRA 모델 저장
model.save_pretrained("./lora-gpt2-model")
tokenizer.save_pretrained("./lora-gpt2-model")

print("🎉 LoRA 학습 완료 및 저장 완료!")

🔹 코드 설명

1️⃣ GPT-2 모델과 토크나이저 로드
2️⃣ LoRA 설정

• r=8: LoRA 랭크(낮을수록 메모리 사용량 감소)
• lora_alpha=16: 학습할 가중치 크기 조정
• target_modules=["c_attn", "c_proj"]: LoRA 적용할 Transformer 레이어 선택
  3️⃣ LoRA 적용 및 학습 가능한 파라미터 확인
  4️⃣ Hugging Face 데이터셋 로드 및 전처리
  5️⃣ 훈련 하이퍼파라미터 설정 (Trainer 사용)
  6️⃣ 모델 학습 진행 (trainer.train())
  7️⃣ 학습된 모델 저장

🔹 결과 및 활용

✅ 원본 GPT-2 모델을 수정하지 않고 LoRA를 활용해 미세 조정
✅ 메모리를 절약하면서 특정 도메인(예: 위키텍스트)에 맞춘 GPT-2 생성 모델 학습 가능
✅ 학습된 LoRA 모델을 저장하고 다시 불러와 사용 가능

🎯 이렇게 하면 LoRA를 사용하여 특정 데이터셋에 최적화된 GPT-2 모델을 만들 수 있습니다! 🚀

🔹 LoRA(Low-Rank Adaptation)란?

LoRA(Low-Rank Adaptation)는 대형 딥러닝 모델을 효율적으로 미세 조정(fine-tuning)하는 방법입니다.
기존 모델의 전체 가중치를 업데이트하는 대신, 저차원 행렬(rank가 낮은 행렬)을 추가하여 학습량을 줄이고 성능을 유지하는 방식입니다.

1️⃣ LoRA가 필요한 이유

✅ 1. 대형 모델의 학습 비용이 너무 큼

• GPT, Stable Diffusion 같은 대형 모델은 **수십억 개의 가중치(파라미터)**를 가짐.
• 전체 모델을 미세 조정하려면 엄청난 계산량과 GPU 메모리가 필요함.

✅ 2. 기존 모델을 유지하면서 새로운 기능 추가

• 원래 모델의 성능을 유지하면서, 특정 작업이나 스타일에 맞게 조정할 필요가 있음.
• LoRA는 원본 모델을 수정하지 않고 추가적인 가중치만 적용하여 이런 요구를 충족함.

2️⃣ LoRA의 원리

LoRA는 기존 모델의 특정 가중치 행렬(예: Transformer의 W_q, W_v)을 직접 업데이트하지 않고,
대신 저차원 행렬(A, B)을 추가하여 모델을 조정하는 방식입니다.

🔸 기존 방법: 일반적인 Fine-Tuning

모든 가중치 θ\thetaθ를 업데이트해야 함.

θ=θ−α⋅∇L(θ)\theta = \theta - \alpha \cdot \nabla L(\theta)θ=θ−α⋅∇L(θ)

💡 문제점: 전체 가중치를 업데이트하므로 연산량과 메모리 사용량이 큼.

🔹 LoRA 방식: 저차원 행렬 추가

기존 가중치 WWW 대신, 작은 행렬 A,BA, BA,B를 추가하여 학습.

W′=W+ABW' = W + ABW′=W+AB

• A: 작은 차원의 행렬 (예: 4096×4)
• B: 더 작은 차원의 행렬 (예: 4×4096)

💡 장점:
✅ 메모리 절약 – 전체 모델을 수정하지 않으므로 GPU 메모리 사용량이 적음.
✅ 빠른 학습 – 필요한 가중치만 업데이트하므로 계산량이 줄어듦.
✅ 원본 모델 유지 – 모델 전체를 바꾸지 않고 필요한 기능만 추가 가능.

3️⃣ LoRA의 활용 분야

LoRA는 다양한 분야에서 대형 모델을 특정 목적에 맞게 조정하는 데 사용됩니다.

🔹 1. 이미지 생성 (Stable Diffusion)

• 특정 캐릭터, 화풍, 스타일을 반영한 모델을 학습하는 데 사용됨.
• 예: 애니메이션 스타일 LoRA, 실사풍 LoRA 등.
• 원본 Stable Diffusion 모델을 유지하면서 추가 학습 가능.

🔹 2. 텍스트 생성 (GPT, LLaMA 등)

• 특정 도메인(예: 법률, 의학)에 맞는 답변을 더 잘하도록 조정 가능.
• ChatGPT의 성능을 유지하면서, 특정 기업용 챗봇으로 최적화 가능.

🔹 3. 음성 합성 (TTS)

• 특정 인물의 목소리를 학습하여 더 자연스럽게 음성을 생성할 수 있음.
• 예: 성우의 목소리를 반영한 AI 보이스 생성.

4️⃣ LoRA vs 기존 Fine-Tuning 방법

비교 항목기존 Fine-TuningLoRA

💡 LoRA는 기존 Fine-Tuning보다 훨씬 가볍고 빠르며, 원본 모델을 보존할 수 있는 강점이 있음.

5️⃣ LoRA 적용 방법 (Stable Diffusion 예시)

만약 Stable Diffusion에서 LoRA 모델을 적용하고 싶다면 다음과 같은 과정을 거칩니다.

1️⃣ 기본 모델 다운로드

• stable-diffusion-v1-5 같은 원본 모델을 가져옴.

2️⃣ LoRA 모델 학습

• 원하는 데이터(예: 특정 캐릭터 이미지)를 준비.
• 기존 모델을 수정하지 않고 LoRA 방식으로 학습 진행.

3️⃣ LoRA 모델 적용

• LoRA 파일(예: .safetensors)을 불러와 원본 모델에 적용.
• diffusers 라이브러리에서 load_lora_weights 같은 기능으로 불러오기 가능.

6️⃣ 결론: LoRA가 왜 중요한가?

✅ 저렴한 비용으로 대형 모델을 커스터마이징 가능
✅ 원본 모델을 수정하지 않고 새로운 기능 추가 가능
✅ 적은 데이터와 자원으로도 빠르게 미세 조정 가능
✅ 이미지 생성, 텍스트 생성, 음성 합성 등 다양한 분야에서 활용 가능

LoRA는 대형 AI 모델을 더 효율적이고 실용적으로 활용할 수 있게 해주는 강력한 기술입니다! 🚀

1. 기본적인 Enum 사용법

Enum을 사용하면 관련된 상수들을 그룹화할 수 있습니다.

from enum import Enum

class Color(Enum):
    RED = 1
    GREEN = 2
    BLUE = 3

print(Color.RED)       # Color.RED
print(Color.RED.value) # 1
print(Color.RED.name)  # 'RED'

2. 자동 값 할당 (auto)

값을 직접 지정하지 않고 자동으로 할당할 수 있습니다.

from enum import Enum, auto

class Status(Enum):
    # auto()는 자동으로 1부터 시작하는 정수 값을 할당합니다.
    PENDING = auto()
    IN_PROGRESS = auto()
    COMPLETED = auto()

print(Status.PENDING.value)  # 1
print(Status.IN_PROGRESS.value)  # 2
print(Status.COMPLETED.value)  # 3

3. 열거형 순회

Enum은 이터러블(iterable)이라서 루프를 돌면서 접근할 수 있습니다.

for color in Color:
    print(color.name, color.value)

# 출력
RED 1
GREEN 2
BLUE 3

4. 문자열 매핑 (Enum을 딕셔너리처럼 활용)

열거형을 사용하면 문자열을 특정 값으로 쉽게 변환할 수 있습니다.

class Role(Enum):
    ADMIN = "admin"
    USER = "user"
    GUEST = "guest"

role = Role["ADMIN"]  # 문자열 키로 접근
print(role.value)  # "admin"

5. 열거형 비교

Enum 값은 동일성(is)과 동등성(==) 비교가 가능합니다.

if role == Role.ADMIN:
    print("관리자입니다.")  # 출력됨

6. 딕셔너리 키로 사용

Enum 값은 해시 가능하므로 딕셔너리의 키로 사용할 수 있습니다.

permissions = {
    Role.ADMIN: "모든 권한",
    Role.USER: "일반 권한",
    Role.GUEST: "읽기 전용"
}

print(permissions[Role.ADMIN])  # "모든 권한"

7. Mixin을 활용한 커스텀 기능 추가

메서드를 포함하여 더 복잡한 Enum을 만들 수도 있습니다.

class ExtendedEnum(Enum):
    @classmethod
    def list(cls):
        return [item.name for item in cls]

class Animal(ExtendedEnum):
    DOG = 1
    CAT = 2
    BIRD = 3

print(Animal.list())  # ['DOG', 'CAT', 'BIRD']

8. IntEnum을 활용한 숫자 Enum

IntEnum을 사용하면 숫자 기반 Enum을 다른 정수와 함께 사용할 수 있습니다.

from enum import IntEnum

class Priority(IntEnum):
    LOW = 1
    MEDIUM = 2
    HIGH = 3

print(Priority.LOW < Priority.HIGH)  # True
print(Priority.LOW + 1)  # 2

9. 플래그(Flag) Enum을 활용한 비트 연산

비트 플래그를 활용할 때 Flag 또는 IntFlag를 사용할 수 있습니다.

비트 연산을 활용하면 권한 시스템을 만들 때 유용합니다.

from enum import Flag, auto

class Permission(Flag):
    READ = auto()
    WRITE = auto()
    EXECUTE = auto()

perm = Permission.READ | Permission.WRITE
print(perm)  # Permission.READ|WRITE

# 특정 권한 포함 여부 확인
print(Permission.READ in perm)  # True
print(Permission.EXECUTE in perm)  # False

Grafana의 대시보드에 2개의 변수를 생성하였습니다.

[종목명/코드]에 입력된 값을 [검색 구분]의 선택값에 따라 서로 다른 컬럼을 검색하는 쿼리 입니다.

where 절에 case when으로 조건을 지정할 수 있습니다.

select stock_code, stock_name, stock_type, last_collect_event_date
from tbl_coporation_info_kor
where (case when '$search_type' = '종목코드' then stock_code = '$search_code'
        else stock_name like '%$search_code%' end)
limit 100;

위 쿼리는 동작은 되지만 실행계획을 보면 stock_code, stock_name에 해당하는 index가 존재하지만 table scan이 발생합니다.

🔹 인덱스를 사용하도록 개선된 코드

select stock_code, stock_name, stock_type, last_collect_event_date
from tbl_coporation_info_kor
where ('$search_type' = '종목코드' and stock_code = '$search_code')
    or ('$search_type' = '종목명' and stock_name like '%$search_code%')
limit 100;

실행계획을 확인해 보면 인덱스를 이용하고 있습니다.

🔹 COLLATION() 함수 사용

set @stock_code := '996161';
SELECT COLLATION(@stock_code);

✅ 결과 예시:

🔹 CHARSET() 함수 사용

set @stock_code := '996161';
SELECT CHARSET(@stock_code);

✅ 결과 예시:

🔹 변수의 Collaton 과 컬럼의 Collation이 다를 경우의 처리 방법

• 일반적인 변수 선언

set @stock_code := '1177851';
SELECT COLLATION(@stock_code);

• Collation을 지정하여 선언

set @stock_code := '1177851' collate utf8mb4_0900_ai_ci;
SELECT COLLATION(@stock_code);

• Convert를 사용하여 변환

set @stock_code := convert('1177851' using utf8mb4);
SELECT COLLATION(@stock_code);

1️⃣ SHOW VARIABLES 사용

SHOW VARIABLES LIKE 'character\_set\_%';

✅ 결과 예시:

2️⃣ 특정 데이터베이스의 문자셋 조회

SELECT SCHEMA_NAME, DEFAULT_CHARACTER_SET_NAME, DEFAULT_COLLATION_NAME
FROM information_schema.SCHEMATA
WHERE SCHEMA_NAME = 'database_name';

✅ 결과 예시:

3️⃣ 특정 테이블의 문자셋 조회 - 1

show create table tbl_stock_list_us;

✅ 결과 예시:

CREATE TABLE `tbl_stock_list_us` (
  `event_date` date NOT NULL COMMENT '기준일',
  `symbol_code` varchar(10) NOT NULL COMMENT '종목 코드',
  `last_open_raw` double NOT NULL COMMENT '시가 Raw',
  `last_max_raw` double NOT NULL COMMENT '고가 Raw',
  `last_min_raw` double NOT NULL COMMENT '저가 Raw',
  `last_close_raw` double NOT NULL COMMENT '종가 Raw',
  `change_precent_raw` double NOT NULL COMMENT '변동률(퍼센트) Raw',
  `volume_raw` double NOT NULL COMMENT '거래량',
  `upd_date` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
  PRIMARY KEY (`event_date`,`symbol_code`),
  UNIQUE KEY `idx_01` (`symbol_code`,`event_date`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

3️⃣ 특정 테이블의 문자셋 조회 - 2

SELECT TABLE_NAME, TABLE_COLLATION
FROM information_schema.TABLES
WHERE TABLE_SCHEMA = 'db_stock' AND TABLE_NAME = 'tbl_stock_list_us';

✅ 결과 예시:

4️⃣ 특정 열(Column)의 문자셋 조회

SELECT COLUMN_NAME, CHARACTER_SET_NAME, COLLATION_NAME
FROM information_schema.COLUMNS
WHERE TABLE_SCHEMA = 'db_stock' AND TABLE_NAME = 'tbl_stock_list_us';

✅ 결과 예시:

MySQL에서 utf8mb4_0900_ai_ci와 utf8mb4_unicode_ci는 둘 다 utf8mb4 문자셋을 사용하는 대소문자 무시(_ci: case-insensitive) 비교(collation) 방식이지만, 주요한 차이점이 있습니다.

🔹 utf8mb4_unicode_ci

• MySQL 5.5+ 버전에서 사용되는 표준 유니코드 정렬 방식
• Unicode 4.0 기준으로 정렬 및 비교 수행
• 일부 문자(예: 이모지, 특수 문자)에 대한 정렬이 최신 유니코드 표준과 다를 수 있음

✅ 특징:

• MySQL 5.5부터 제공되며 널리 사용됨
• 성능은 utf8mb4_general_ci보다는 느리지만 정확함
• 최신 유니코드 규칙을 반영하지 못할 수 있음

🔹 utf8mb4_0900_ai_ci

• **MySQL 8.0+**에서 제공하는 새로운 유니코드 정렬 방식
• Unicode 9.0 기준으로 정렬 및 비교 수행
• AI (Accent-Insensitive): 악센트 무시 (é == e)
• CI (Case-Insensitive): 대소문자 무시 (A == a)
• 성능이 개선되었으며 더 정확한 유니코드 정렬을 지원

✅ 특징:

• MySQL 8.0 이상에서 권장됨
• 최신 유니코드 표준을 반영하여 더 정확한 정렬 방식 제공
• 성능 최적화됨

🔹 정리 (비교)

비교 항목utf8mb4_unicode_ciutf8mb4_0900_ai_ci

📌 MySQL 8.0 이상을 사용한다면 utf8mb4_0900_ai_ci를 권장
📌 MySQL 5.7 이하에서는 utf8mb4_unicode_ci를 사용