Langchain with Ollama (250521)

# > ollama run llama3 

import ollama

stream = ollama.generate(model='llama3', prompt='하늘이 왜 파란지에 대한 답을 한글로 말해줘')
print(stream['response'])

A question that has puzzled humans for centuries! 🤔

So, why is the sky blue? Let me break it down in simple terms:

**Short answer:** The sky appears blue because of a phenomenon called Rayleigh scattering.

**Longer explanation:**

When sunlight enters Earth's atmosphere, it encounters tiny molecules of gases like nitrogen (N2) and oxygen (O2). These molecules are much smaller than the wavelength of light. As a result, they scatter shorter (blue) wavelengths more efficiently than longer (red) wavelengths.

Think of it like a game of pool: when a cue ball hits a group of smaller balls, they bounce around in all directions, spreading out. Similarly, the blue light from the sun is scattered in all directions by these tiny molecules, reaching our eyes and making the sky appear blue.

**Other factors:** While Rayleigh scattering is the main culprit behind the blue sky, other atmospheric conditions can influence its color:

1. **Atmospheric particles:** Tiny aerosols like dust, pollen, or smoke can scatter light, making the sky appear more hazy or gray.
2. **Clouds:** Clouds and fog can reflect sunlight, adding to the sky's brightness and sometimes changing its apparent color.
3. **Angle of the sun:** The position of the sun in the sky affects its apparent color. When it's overhead, the light has to travel through less atmosphere, making it appear more intense and blue.

So, there you have it! The beauty of the blue sky is a result of the harmonious combination of light, molecules, and atmospheric conditions. 🌌

# https://wikidocs.net/233805

# LangSmith 추적을 설정합니다. https://smith.langchain.com   ---> Lang Smith 이해 먼저
# !pip install langchain-teddynote

from langchain_teddynote import logging

# 프로젝트 이름을 입력합니다.
logging.langsmith("llama3_Model_20521")

LangChain/LangSmith API Key가 설정되지 않았습니다. 참고: https://wikidocs.net/250954

랭체인 개요

# RAG 마스터 : 랭체인으로 완성하는 LLM 서비스 (p.31~)
# 랭체인 주요 패키지

## langchain-core : 랭체인 생태계의 기본이 되는 패키지로 다른 많은 패키지들이 이에 의존
##                  대규모 언어모델, 데이터 벡터 저장소(Vector Store), 검색기(Retriever)와 같은 중요한 기능들을 정의하는 기본 구조 포함
## langchain : 애플리케이션의 구조를 만드는 체인(chain), LLM을 사용해 작업을 처리하는 지능형 시스템인 에이전트(Agent),
##             그리고 정보를 검색하는 검색기(retriever) 전략 등을 포함한다.
## langchain-community : 랭체인 커뮤니티에서 유지 관리하는 다양한 타사 서비스 통합을 포함
##                       LLM, Vector Store, Retriever 등을 선택적으로 사용 가능함.
## 파트너 패키지 : langchain-[partner] -> langchain-openai, langchain-anthropic 등

# 랭 그래프 : 그래프 기반 모델링 패키지
# 랭 서브 : REST API 배포를 도와주는 패키지

from langchain_community.chat_models import ChatOllama
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_teddynote.messages import stream_response

# Ollama 모델을 불러옵니다.
llm = ChatOllama(model="llama3")

# 프롬프트
prompt = ChatPromptTemplate.from_template("{topic} 에 대하여 간략히 설명해 줘.")

# 체인 생성
chain = prompt | llm | StrOutputParser()

# 간결성을 위해 응답은 터미널에 출력됩니다.
answer = chain.stream({"topic": "deep learning"})

# 스트리밍 출력
stream_response(answer)

C:\Users\wonta\AppData\Local\Temp\ipykernel_10932\713405683.py:7: LangChainDeprecationWarning: The class `ChatOllama` was deprecated in LangChain 0.3.1 and will be removed in 1.0.0. An updated version of the class exists in the :class:`~langchain-ollama package and should be used instead. To use it run `pip install -U :class:`~langchain-ollama` and import as `from :class:`~langchain_ollama import ChatOllama``.
  llm = ChatOllama(model="llama3")


😊

Deep learning is a subset of machine learning that uses artificial neural networks to analyze and learn from data. Here's a brief overview:

**What are Neural Networks?**

Artificial neural networks are composed of interconnected nodes (neurons) that process and transmit information. Each node applies an activation function to the weighted sum of its inputs, producing an output that is passed to subsequent nodes.

**How do Deep Learning Models Work?**

Deep learning models typically consist of multiple layers of neural networks, each processing a different level of abstraction in the data. The layers are designed to:

1. **Extract features**: Early layers focus on simple features like edges and lines.
2. **Recognize patterns**: Middle layers learn more complex patterns, such as shapes and textures.
3. **Make predictions**: Later layers integrate information from previous layers to make final predictions or decisions.

**Key Characteristics of Deep Learning:**

1. **Hierarchical representations**: Deep learning models learn hierarchical representations of data, allowing them to capture complex relationships.
2. **Large datasets**: Deep learning models require large datasets to train and improve their performance.
3. **Multiple layers**: Multiple layers allow deep learning models to extract increasingly abstract features from the data.
4. **Non-linear transformations**: Each layer applies non-linear transformations to the input data, enabling the model to learn complex relationships.

**Applications of Deep Learning:**

1. **Computer Vision**: Image recognition, object detection, facial recognition
2. **Natural Language Processing (NLP)**: Text classification, sentiment analysis, language translation
3. **Speech Recognition**: Speech-to-text systems and voice assistants
4. **Robotics**: Control systems for robots and autonomous vehicles

**Challenges and Limitations:**

1. **Training time**: Deep learning models can be computationally intensive and require significant training time.
2. **Data quality**: The quality of the training data is crucial, as poor-quality data can lead to poor performance or overfitting.
3. **Interpretability**: Deep learning models can be difficult to interpret, making it challenging to understand their decision-making processes.

That's a brief overview of deep learning! 💡

RAG(Retrieval-Augmented Ceneration) 검색 증강 생성

# 외부 데이터베이스나 문서에서 정보를 검색하여 응답을 생성하는 방식
# 랭체인으로 이러한 시스템을 구축하면 방대한 문서에서 필요한 정보를 찾아 정확한 답변 제공 가능

랭체인의 핵심 구성요소

- 대규모 언어모델(LLM)

- 체인(Chains)

- 프롬프트(Prompts)

- 파서(Parsers)

# ollama3 클라이언트를 이용,

from langchain_community.chat_models import ChatOllama

client = ChatOllama()   # 모델을 미리 정의하지 않고 시작
# client = Chatollama(model = "llama3")

# 러너블 표준 인터페이스
# 여러 공통 메서드를 제공하는 표준 인터페이스를 사용

# 파이프 연산자

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough

from langchain_community.chat_models import ChatOllama


# {topic}에 대한 설명을 요청하는 프롬프트 템플릿 정의
prompt = ChatPromptTemplate.from_template(
    "주제 {topic}에 대해 짧은 설명을 해주세요."
)

# 출력 파서를 문자열로 설정
output_parser = StrOutputParser()
client = ChatOllama(model = "llama3")  

# 파이프라인 설정 : 주제 입력 -> 프롬프트 생성 -> 모델로 응답 생성 -> 문자열로 파싱
chain = (
    {"topic": RunnablePassthrough()}
    | prompt
    | client
    | output_parser
)

# "더블딥" 주제로 설명 요청

chain.invoke("더블딥")

'I think you meant "Double Deep" as in Double Deeper, a popular Korean fashion trend! 😊\n\nDouble Deeper refers to wearing two layers of clothing that are typically worn separately, such as a sweater over a shirt, or a dress over leggings. This fashion trend is characterized by layering different textures, colors, and patterns to create a unique and stylish look.\n\nIn Korea, Double Deeper has become a popular way for young women to express themselves through fashion, experimenting with different combinations of clothing items to create a bold and eye-catching style. It\'s all about mixing and matching different pieces to create a one-of-a-kind outfit! 💃'

# p. 56~
# 질문을 생성하는 템플릿 정의
analysis_prompt = ChatPromptTemplate.from_template("이 대답을 영어로 번역해 주세요: {answer}")

# 이전에 정의된 체인과 새로운 작업을 연결하는 체인 구성
composed_chain = {"answer" : chain} | analysis_prompt | client | StrOutputParser()

# "더블딥" 이라는 주제로 응답을 생성하고 체인 실행
composed_chain.invoke({"topic" : "더블딥"})

'Here\'s the translation:\n\nI\'d be happy to provide a brief overview on the topic "더블딥" (Double Deep).\n\nDouble Deep is a type of neural network architecture that consists of two hidden layers, each with its own set of learnable weights and biases. This architecture is designed to improve the performance of deep learning models by increasing the capacity of the model to represent complex relationships between inputs and outputs.\n\nThe Double Deep architecture is particularly useful for tasks such as image classification, object detection, and sequence prediction, where the presence of multiple hidden layers can help to capture subtle patterns and features in the data. The additional layer also provides more opportunities for the model to learn non-linear representations of the input data, which can lead to improved predictive accuracy.\n\nOverall, Double Deep is a powerful architecture that has been shown to be effective in a wide range of applications, from computer vision to natural language processing.'

# 실행되는 순서 : 결합된 체인(composed chain)은 아래의 연속된 작업을 자동을 처리함

# "answer"라는 키에 앞서 정의된 chain에서 생성된 응답 입력
# 이 응답을 영어로 번역하는 프롬프트로 전달
# client(llama3) 실행하여 번역된 응답을 생성
# StrOutpuParser를 통해 문자열로 변환

# 람다 함수를 사용하여 입력 데이터를 다른 형식으로 변환한 후 체인에 연결하는 방법 (p.58)

# 이전에 정의된 값들
model = ChatOllama(model = "llama3")
prompt = ChatPromptTemplate.from_template(
    "{topic}에 대해 짧은 설명을 해주세요."
)
chain = prompt | model | StrOutputParser()

analysis_prompt = ChatPromptTemplate.from_template("이 대답을 영어로 번역해 주세요: {answer}")

# 람다 함수를 사용한 Chain 구성
composed_chain_with_lambda = (
    # 이전에 정의된 Chain을 사용하여 입력 데이터 받아오기
    chain

    # 입력 데이터를 "answer" 키로 변환하는 람다 함수
    | (lambda input : {"answer" : input})

    # "answer" 키를 가진 데이터를 영어로 번역하도록 프롬프트에 전달
    | analysis_prompt

    # 프롬프트에서 생성된 요청을 모델에 전다하여 결과를 생성
    | model

    # 모델에서 변환된 결과를 문자열로 파싱
    | StrOutputParser()
)

# "더블딥" 이라는 주제로 답변을 생성하고, 영어로 번역
composed_chain_with_lambda.invoke({"topic" " 더블딥"})

# invoke() 메서드 - 체인 실행
# 람다 함수를 사용하여 입력을 변환하는 방식은 스트리밍 작업과 호환되지 않을 수 있음 주의 (p.59)

'Here is the translation:\n\nThe "Double Deep" topic refers to the concept of using two or more neural network architectures, each with its own set of weights and biases, in a hierarchical manner to solve complex problems.\n\nIn traditional deep learning approaches, a single neural network is used to learn features from raw data. In contrast, Double Deep models use multiple networks, often with different architectures or specializations, to learn features at different levels of abstraction.\n\nThis approach can be useful for tasks that require processing multiple types of information or handling complex relationships between variables. For example, in natural language processing (NLP), a Double Deep model might consist of a first network that learns word-level representations and a second network that learns sentence-level representations to capture contextual dependencies.\n\nBy combining the strengths of multiple networks, Double Deep models can potentially achieve better performance, improved robustness, or even novel capabilities compared to single-network approaches. 💡'