Okay. So recently I came across this project called LlamaOCR. So this seems to be something that's been created by together.AI.

Now that they're serving the Llama 3.2 vision model, and specifically I think the 90 billion version of that model.

And see what they've basically done is make an NPM package that you can simply just import LlamaOCR, pass in a file path, pass in your together API key, and you will get a decent result out of this.

So, what I'll do in this video is take a look at how it actually works.

We'll look at recreating this in Python, so that could you use it in Python. We'll then have a look at like how you could do this fully locally with something like Ollama.

And finally I'll wrap it up by talking about how you could use this in an agent and give you some examples of how you could use this for helping to scrape websites, et cetera.

So let's jump in and have a look at what they built.

All right, to use this is pretty simple. We can just basically take a screenshot or something, drag it in there.

And automatically they will convert it and give us some kind of output on markdown. So you can see that here in this case, we've gone from texts that was not editable because it was a screenshot to having texts that's fully editable, and it's retained the title and stuff like that in here.

Now you can see if we take one of the receipts that I've done things with the vision Phi-3 with and stuff like that.

And have a look at this. We can see how does this actually come out? Okay, so this one's actually taking longer to process.

All right. So we've got in a Walmart, we've
got the different things out, and in this case, we've actually
gotten a pretty good run.

And what do I mean by that? Because this is a stochastic model,
we will get different versions. So you can see here early on
here's one that I did, where we got the item sold being really big.

We didn't get the Walmart being so big, and we didn't perhaps get all the sort
of formatting as good as we did this time, like here, we can see clearly that, okay, it looks like it's basically
gotten all the prices correct.

It's gotten the subtotal correct. It's basically put the tax
on one line, et cetera. And interestingly, it's put the
barcode number, this TC number, actually after what it's got in there.

So you're always going to have a hit
and miss with this kind of thing, but generally you're going to
find it can do a pretty good job.

Now, here, we can see that
it's putting stuff out of order that, okay, we've got this part, and then it's trying to do it as the
markdown part.

And then we've got in markdown hittings and notated with.

And then we've got some notes about
the markdown actually in there. All right, so let's jump into
the code and actually have a look at recreating this in Python.

All right. So if we come in here and actually have
a look at the code for this, we can see that on the whole, it's a pretty cool,
but reasonably simple sort of package.

So a nice example of just taking
something where you use a large language model endpoint or
in this case a VLM endpoint, and actually just turn it
into something really useful.

So they have the demo up,
which I showed you earlier on.

if we come in here and actually look at the code. Sure enough, this whole thing is just one file, one TypeScript file in here.

and we can see that basically it's just importing from Together AI. We can see there's choice of model in there.

And probably the most important part is that we can actually see what the prompt is that's being used for this.

and it's all being done in a single pass with this particular prompt in here. If we look at the prompt in here, actually, there's some kind of interesting things in here.

We can see that first off it tells it to only solely return markdown content without any additional explanations or comments.

that is not what we got all the time when we used the managed service, that sometimes it was giving comments about the content, et cetera.

And perhaps that really shows how good is it, how not good is it in here. All right. So if we want to recreate this with Python, I've just put together a simple little notebook that allows us to do the exact same thing in Python here.

So we're using the Together package because I'm going to stick to using their API since that's what the other one was already using.

And if we come in here, we can actually see the models that they've got in here.

So we can just come in and basically look at a list of the models and then I'm filtering it out for vision models.

Okay. So we've got the 11 billion model in there and we've also got the 90 billion. So we'll use the 90 billion.

I think that's what they're using on their site as well in here. Actually just look at the Together AI docs, we can see under vision we can see that, okay, they do have these two models supported.

They're also offering a free model endpoint if you want to use that.

So that you can actually, we could actually change it to this if we wanted to use a totally free one.

Though, I'm not sure how long that's actually going to be up here. And then we can just see, okay, they've got some examples in here of how to do it.

So there's two main ways that you can do it. You can either pass in an image URL where it will go and get the image from the URL.

and you can see that they're doing that here. You will need to change the streaming code out to, for it to work nicely in CoLab.

In the version I've got, I've already changed that. And then they've got another version which is doing it with a local image where you were going to basically need to base64 encode the image.

And in this case, you want to make sure that you've got something that if you're going to be using JPEG, you need to encode as JPEG.

So I've put in some code for taking care of all of these in the notebook. Lastly, a key thing that is important is just exactly how do they work out the number of tokens that you're using.

So they show that for vision models, images are converted from 1,600 to 6,400 tokens, depending on the image size.

So here is the actual formula for that if you want to actually calculate how many tokens that you're using each time.

So if we come over and look here, we can see that the 90 billion model is going to be a dollar 20 per million tokens and the 11 billion malls on the 18 cents per million tokens.

So definitely if you can get your tasks to work in the smaller model, it's going to be a lot cheaper here.

Okay. So jumping in here, we can basically look at the model lists. We can see that they've got a number of these models available.

Unfortunately, the one that I really would like to compare this against is the Qwen 2 VL model, which for some reason they don't seem to be serving on their service.

Then if we just take their code, we've got two ways of getting the image into the Together API here.

And this is pretty consistent with Gemini, pretty consistent with other models and stuff as well, is that you tend to either basically do it by sending it a web URL and putting it up there or you do it locally.

So this is the example of sending a web URL. You can see that this basically is this image which comes from this article, about Sam Altman being involved in this startup called Thrive AI.

And it's basically just their user interface in here of their product.

So we can see there's image credits and stuff like that, but we can also see that it's got UI in there.

We can see a bunch of different things. We've got morning report, noon report, evening report, et cetera as we go through this.

Now I fixed up their streaming a little bit in here. The other thing though, is we're using their particular prompt yet, which the prompt is quite different.

So this is, describe the attached screenshot or UI mock up. Give us information of headers, footers, use the exact text from the screenshot.

So while we can see that it is doing it, is getting the text out, and it is OCRing the text.

We're getting a lot of description about what is actually on the page as we go through this. And I guess the main goal here is not to have that.

We really want the OCR just to give us the actual text that came back and then we can use this. So one of the techniques that you can do though, is have one pass where you get a description out, and one pass where you get the OCR out, that can be quite useful.

Alright, the second way to do this is to load the local images here.

So here I've basically got our Walmart receipt that I've used in a number of videos now. And you can see for this, I'm actually just using a real simple prompt of what is the image.

And sure enough, we're basically now going to encode this. So when we encode it, we need to make sure that the mime type of the encoding matches what we actually encoded.

So this is a JPEG image. We can see the mime type down here is also a JPEG image in here.

If this is a PNG, we need to basically replace this. So you'll see that I've created my own class in a second for doing this.

We're passing in the model there. again, fixing up the streaming. And you can see that sure enough, the output that we get while it's consistent, we still have a bit more of that sort of description going on.

It looks like it's getting most of the information out, but we've got these sort of really clear descriptions that we don't necessarily want.

All right. So what I wanted to do was make my own sort of edited version of this, where we actually make this image process a class, and then we can pass in the model.

We can pass in the prompt. You can see the model's going to default to the 11 B version in here.

And that one of the other things too, is based on what we put in, it will basically work out what is the correct mime type for the image.

So it can support PNG, JPEG, GIF files and WebP files in here, and it will then handle the encoding for us.

It will then pass this up. And you can see the prompt that we've got and the model that we've got set in here.

And then you can see to use this, all we need to do is instantiate our image processor, pass in a new prompt, if you want to override the prompt.

And actually here, what I'm going to do is go with the system prompt that they have. So this is the system prompt, taken from what they actually used in their LlamaOCR.

So I basically just passing that in. And then I can pass in some photos. This one actually doesn't exist.

So I want to test that, will it fail gracefully, et cetera, as we go through this. And can see sure enough, if we take that receipt, but now a PNG version of it.

it has no problem of sort of, you know, handling that. And you can see that now because we're prompting it specifically for the OCR, we're getting much more of sort of the markdown output.

Okay. So just to test out the MIME types part.

I'm going to put in a WebP image and you can see that it handles this quite nicely. So this is the image that I used earlier on.

It handles quite nicely. It extracts it out, actually gives the link as a URL link in here. Although, if we look at it carefully, we can see that it's saying that this is a heading, whereas this is clearly not any more of a heading than the second line or the other lines in there.

And this kind of brings me to the point around some of the issues that you're going to face in doing this is that you can't always rely on the VLM to extract, the OCR and the structure perfectly.

Okay. So one of the ways that you can get structure is by creating what we call a regions of interest model.

So this is a picture from a project that I worked on about six years ago.

At the time Google didn't have a good OCR system for Thai. And this particular customer wanted to be able to scan ID cards and extract out the various information.

So the way this works is you basically train up an object detection model to find the relevant parts in there.

And then you pass each of them to an OCR system. So in this case, I trained up an OCR model for Thai.

and we trained a separate object detection, regions of interest model to actually find the different parts. And then we'd basically take those parts and run the OCR on those specific boxes.

Because of that, we knew exactly the structure of it. And so we knew what was what in each place kind of thing.

So, if you're trying to do like a hardcore OCR task, you can go for sort of regions of interest models.

The other trick though, that you can do, which works pretty well is that with the smaller model, if you don't have huge issues around latency, et cetera, you can actually get it to do the OCR multiple times, say three times, and then pass each of those three things into a larger language model for a language model as a judge and tell it, okay, here are three versions of this OCR.

Because one of the tricks that you find is that these things don't tend to hallucinate consistently. Often, when they hallucinate, they will get it right two out of three times, and then get it wrong one time.

So if you can give the things to another
large language model, that's one way that you can fix up some of the mistakes.

And then you can also do that with
playing around with the prompt to help it in that kind of style.

So since the model did so well
here, the other thing that you could do is you could run this locally. So you can convert this code
to basically run the Ollama version locally, quite easily.

And then if we come and look at Ollama,
we can see that Ollama has got both the 11 B and the 90B versions that you can run.

Now the 90B version, you're probably
going to need quite a lot of RAM for that.

So maybe that's not that practical,
but certainly the 11B version is something that could run quite easily
on a home computer to do this task.

So lastly, just to finish up. If you're going to be doing this
kind of thing with agents, where this can become really useful is
where you're scraping web pages that have information on them like this.

So here, we've got this article and
then it's got the actual UI in here.

LlamaOCR - Building your Own Private OCR System

HI my name is Sam Witteveen, I have worked with Deep Learning for 9 years and with Transformers and LLM for 5+ years.  I was appointed a Google Developer Expert for Machine Learning in 2017 and I currently work on LLMs and and since earlier in 2023 on Autonomous Agents. 

Sam Witteveen

최근 Sam Witteveen은 **LlamaOCR이라는 프로젝트를 소개하며, 이는 TogetherAI에서 개발**되었습니다. LlamaOCR은 Llama 3.2 vision 모델을 활용하여 이미지 속 텍스트를 추출하는 NPM 패키지입니다. 간단하게 파일 경로와 TogetherAI API 키를 입력하면 준수한 결과를 얻을 수 있습니다.

이 비디오에서는 LlamaOCR의 작동 방식을 살펴보고, **Python으로 이를 재현하는 방법**을 설명합니다. 또한 Ollama와 같은 도구를 사용하여 완전히 로컬 환경에서 이를 구현하는 방법도 다룹니다.

스크린샷을 LlamaOCR에 드래그 앤 드롭하면 자동으로 텍스트로 변환되어 Markdown 형식으로 출력됩니다. **수정 불가능한 이미지 텍스트를 완전히 편집 가능한 텍스트로 변환**할 수 있습니다.

영수증 이미지를 처리한 결과, Walmart 영수증의 항목과 가격을 비교적 정확하게 추출했습니다. 하지만 **모델의 확률적 특성으로 인해 결과는 매번 다를 수 있습니다**. 이전에는 항목 이름이 크게 강조되거나 포맷팅이 완벽하지 않은 경우도 있었습니다.

때로는 항목 순서가 뒤섞이거나 Markdown 주석이 텍스트에 포함되는 경우도 있습니다. **이러한 한계에도 불구하고 전반적으로 꽤 좋은 성능을 보여줍니다**.

LlamaOCR의 코드는 비교적 간단하며, **대규모 언어 모델(LLM) 엔드포인트를 활용하여 유용한 도구로 변환한 좋은 예시**입니다. 데모 코드는 하나의 TypeScript 파일로 구성되어 있으며, TogetherAI에서 필요한 모듈을 가져와 사용합니다.

프롬프트에는 몇 가지 흥미로운 지침이 포함되어 있습니다. 예를 들어, **추가 설명이나 주석 없이 Markdown 콘텐츠만 반환하도록 지시**합니다. 그러나 실제 서비스에서는 때때로 주석이 포함된 결과가 나타나기도 합니다.

Python으로 재현하기 위해 간단한 노트북을 만들었습니다. TogetherAI API를 사용하며, 사용 가능한 비전 모델 목록을 확인하고 900억 파라미터 모델을 사용합니다. **TogetherAI는 무료 모델 엔드포인트도 제공**하지만, 얼마나 오래 유지될지는 불확실합니다.

이미지를 API에 전달하는 방법은 URL을 사용하거나 로컬 이미지를 Base64로 인코딩하는 두 가지가 있습니다. **이미지 크기에 따라 토큰 수가 결정되며, 900억 파라미터 모델은 100만 토큰당 1.2달러, 110억 파라미터 모델은 100만 토큰당 18센트**입니다.

🖼️ 이미지 처리 및 프롬프트 조정

TogetherAI API에 이미지를 보내는 방법은 웹 URL을 사용하거나 로컬 이미지를 사용하는 것입니다. 웹 URL을 사용하는 경우, **이미지 내 텍스트를 추출하고 UI 요소를 설명**합니다. 하지만 때로는 OCR 결과만 필요한 경우가 있습니다.

로컬 이미지를 사용하는 경우, **이미지 인코딩 시 MIME 타입이 일치해야 합니다**. JPEG 이미지로 인코딩했다면 MIME 타입도 JPEG로 설정해야 합니다. 그렇지 않으면 오류가 발생할 수 있습니다.

이미지 처리 클래스를 만들어 모델과 프롬프트를 전달할 수 있습니다. **이미지 형식에 따라 자동으로 MIME 타입을 결정하고 인코딩을 처리**합니다. LlamaOCR에서 사용된 시스템 프롬프트를 적용하면 OCR 결과가 더욱 정확하게 출력됩니다.

VL 모델이 항상 완벽하게 OCR 및 구조를 추출하지는 못합니다. **구조를 얻기 위해 관심 영역(regions of interest) 모델을 사용할 수 있습니다**. 이는 특정 영역을 감지하고 해당 영역에 대해 OCR을 수행하는 방식입니다.

또 다른 방법은 **작은 모델을 사용하여 OCR을 여러 번 수행하고, 그 결과를 LLM에 전달하여 컨센서스 버전을 얻는 것**입니다. 모델은 일관되게 잘못된 결과를 내놓지 않는 경향이 있으므로, 이러한 방식으로 오류를 수정할 수 있습니다.

🏠 로컬 환경에서 Ollama 사용하기

모델이 잘 작동한다면, 코드를 Ollama 버전으로 변환하여 로컬에서 실행할 수 있습니다. **Ollama는 110억 및 900억 파라미터 버전을 모두 제공**합니다. 900억 파라미터 버전은 많은 RAM이 필요하지만, 110억 파라미터 버전은 가정용 컴퓨터에서도 쉽게 실행할 수 있습니다.

🕸️ 웹 스크래핑 및 에이전트 활용

웹 페이지를 스크래핑할 때 OCR은 매우 유용합니다. **웹 페이지의 HTML을 Markdown으로 변환하고, 이미지도 추출하여 함께 사용할 수 있습니다**. 이미지를 OCR하고 설명을 생성하여 LLM에 전달하면 웹 페이지에서 가장 관련성 높은 정보를 추출할 수 있습니다.

전반적으로, 클라우드 기반 LLM을 사용하면 OCR이 훨씬 쉬워지고 있습니다. **Llama 3.2 모델 외에도 Gemini Pro, GPT-4V 모델 등을 사용할 수 있습니다**. 이러한 모델은 텍스트 정보뿐만 아니라 차트, 그림 등에서도 정보를 추출하는 데 유용합니다.

이러한 기술은 RAG 파이프라인에서 멀티모달 RAG를 구현하는 데에도 활용될 수 있습니다. 더 자세한 내용은 Patreon에서 다룰 예정이며, CoLab 노트북을 공유하여 직접 사용해 볼 수 있도록 할 예정입니다.

어떤 종류의 OCR을 시도하고 있는지, 그리고 RAG 파이프라인에 어떻게 통합하고 있는지 공유해 주시면 감사하겠습니다. 비디오가 유용했다면 좋아요와 구독을 부탁드립니다.

좋아요. 최근에 LlamaOCR이라는 프로젝트를 접하게 되었는데요. Together.AI에서 만든 것 같습니다.

Llama 3.2 비전 모델, 특히 900억 버전의 모델을 제공하고 있습니다.

기본적으로 NPM 패키지를 만들어서 LlamaOCR을 가져오고 파일 경로와 Together API 키를 전달하면 괜찮은 결과를 얻을 수 있습니다.

그래서 이 비디오에서는 실제로 어떻게 작동하는지 살펴보겠습니다.

파이썬에서 이것을 재현하는 방법을 살펴보고 파이썬에서 사용할 수 있도록 하겠습니다. 그런 다음 Ollama와 같은 것으로 완전히 로컬에서 이 작업을 수행하는 방법을 살펴보겠습니다.

마지막으로 에이전트에서 이것을 사용하는 방법과 웹사이트 스크랩 등에 사용하는 방법에 대한 몇 가지 예를 들어 마무리하겠습니다.

자, 그들이 만든 것을 살펴봅시다.

좋습니다. 사용법은 매우 간단합니다. 기본적으로 스크린샷을 찍거나 드래그하면 됩니다.

자동으로 변환되어 마크다운으로 출력이 제공됩니다. 보시다시피 이 경우 스크린샷이라서 편집할 수 없었던 텍스트가 완전히 편집 가능한 텍스트로 바뀌었고 제목 등이 그대로 유지되었습니다.

이제 비전 Phi-3 등으로 작업했던 영수증 중 하나를 가져와 보겠습니다.

이것을 살펴봅시다. 실제로 어떻게 나오는지 봅시다. 좋습니다. 이 영수증은 처리하는 데 시간이 더 오래 걸립니다.

좋습니다. Walmart에서 여러 품목을 가져왔습니다. 이번에는 꽤 잘 작동했습니다.

무슨 뜻이냐면, 이것은 확률적 모델이기 때문에 다른 버전이 나올 수 있습니다. 초기에 제가 했던 것 중 하나를 보면 판매된 품목이 매우 크게 나왔습니다.

Walmart이 그렇게 크게 나오지 않았고, 이번처럼 모든 형식이 제대로 갖춰지지 않았습니다. 여기를 보면 가격을 모두 제대로 가져온 것 같습니다.

합계는 맞게 나왔습니다. 기본적으로 세금을 한 줄에 넣고 등등. 그리고 흥미롭게도 바코드 번호인 이 TC 번호를 실제로 그 안에 있는 내용 뒤에 넣었습니다.

그래서 이런 종류의 작업은 항상 성공과 실패가 있을 수 있지만, 일반적으로 꽤 잘 해낼 수 있다는 것을 알게 될 것입니다.

자, 여기서 보면 순서가 뒤죽박죽인 것을 알 수 있습니다. 좋아요, 이 부분이 있고, 마크다운 부분으로 하려고 합니다.

그리고 마크다운 적중과 표기가 있습니다.

그리고 마크다운에 대한 몇 가지 메모가 실제로 있습니다. 좋습니다, 이제 코드로 뛰어들어 파이썬으로 이것을 재현하는 것을 살펴봅시다.

좋습니다. 여기로 들어와서 이 코드에 대해 실제로 살펴보면, 전체적으로 꽤 멋지지만, 상당히 간단한 종류의 패키지라는 것을 알 수 있습니다.

따라서 대규모 언어 모델 엔드포인트 또는 이 경우 VLM 엔드포인트를 사용하는 것을 가져와서 실제로 매우 유용한 것으로 바꾸는 좋은 예입니다.

그래서 그들은 데모를 올려놓았는데, 제가 앞서 보여드렸습니다.

여기로 들어와서 코드를 실제로 보면, 물론 이 모든 것이 단 하나의 파일, 여기에 있는 하나의 TypeScript 파일입니다.

그리고 기본적으로 Together AI에서 가져오고 있다는 것을 알 수 있습니다. 모델 선택이 있다는 것을 알 수 있습니다.

그리고 아마도 가장 중요한 부분은 실제로 이것에 사용되는 프롬프트가 무엇인지 알 수 있다는 것입니다.

그리고 이 특정 프롬프트로 단일 패스로 모두 수행됩니다. 여기에서 프롬프트를 보면 실제로 여기에 몇 가지 흥미로운 것들이 있습니다.

우선 추가 설명이나 주석 없이 마크다운 콘텐츠만 반환하라고 지시합니다.

관리형 서비스를 사용할 때 항상 그런 것은 아니었습니다. 때로는 콘텐츠 등에 대한 주석을 제공하기도 했습니다.

그리고 아마도 그것이 얼마나 좋은지, 얼마나 좋지 않은지를 실제로 보여줄 것입니다. 좋습니다. 파이썬으로 이것을 재현하려면 파이썬에서 똑같은 작업을 수행할 수 있도록 간단한 작은 노트북을 만들었습니다.

자, 우리는 Together 패키지를 사용하고 있습니다. 다른 API도 이미 이걸 사용하고 있어서, 저는 Together API를 계속 사용할 겁니다.

여기 들어와 보면, 실제로 그들이 가지고 있는 모델들을 볼 수 있습니다.

여기 들어와서 기본적으로 모델 목록을 보고, 저는 여기서 비전 모델을 필터링하고 있습니다.

좋습니다. 110억 개 모델이 있고, 900억 개 모델도 있습니다. 900억 개 모델을 사용하겠습니다.

제 생각에 그들도 자기네 사이트에서 이걸 사용하고 있을 겁니다. Together AI 문서를 보면, 비전에서 이 두 모델이 지원된다는 것을 알 수 있습니다.

원한다면 무료 모델 엔드포인트도 제공합니다.

그래서 완전히 무료인 것을 사용하고 싶다면 이걸로 바꿀 수도 있습니다.

하지만 이게 얼마나 오래 올라와 있을지는 모르겠습니다. 그리고 여기 사용법 예시가 있습니다.

사용할 수 있는 주요 방법은 두 가지입니다. 이미지 URL을 전달해서 URL에서 이미지를 가져오게 할 수도 있고,

여기서 그렇게 하고 있는 것을 볼 수 있습니다. CoLab에서 제대로 작동하려면 스트리밍 코드를 변경해야 합니다.

제가 가진 버전에서는 이미 변경했습니다. 그리고 로컬 이미지를 사용하는 또 다른 버전이 있는데, 여기서는 기본적으로 이미지를 base64로 인코딩해야 합니다.

이 경우, JPEG를 사용하려면 JPEG로 인코딩해야 합니다.

그래서 노트북에 이 모든 것을 처리하는 코드를 넣어 놨습니다. 마지막으로, 중요한 핵심은 정확히 얼마나 많은 토큰을 사용하는지 계산하는 방법입니다.

비전 모델의 경우, 이미지 크기에 따라 이미지가 1,600개에서 6,400개의 토큰으로 변환된다고 합니다.

각각 사용할 때마다 얼마나 많은 토큰을 사용하는지 실제로 계산하고 싶다면 여기에 실제 공식이 있습니다.

여기 보시면 900억 개 모델은 토큰 백만 개당 1달러 20센트이고, 110억 개 모델은 토큰 백만 개당 18센트입니다.

따라서 작업을 더 작은 모델에서 실행할 수 있다면 훨씬 저렴할 것입니다.

좋습니다. 여기 들어가서 모델 목록을 보면 다양한 모델을 사용할 수 있다는 것을 알 수 있습니다.

아쉽게도 제가 정말 비교하고 싶은 모델은 Qwen 2 VL 모델인데, 어쩐지 이 서비스에서는 제공하지 않는 것 같습니다.

그럼 그들의 코드를 가져와서 이미지를 Together API에 넣는 두 가지 방법이 있습니다.

이것은 Gemini와도 상당히 일치하고 다른 모델과도 일치하는 부분인데, 기본적으로 웹 URL을 보내서 올리거나 로컬에서 처리하는 경향이 있습니다.

이것은 웹 URL을 보내는 예시입니다. 기본적으로 샘 알트만이 Thrive AI라는 스타트업에 참여했다는 기사의 이미지를 볼 수 있습니다.

그리고 기본적으로 제품의 사용자 인터페이스가 있습니다.

이미지 크레딧 등이 있지만 UI도 있다는 것을 알 수 있습니다.

다양한 것들이 있습니다. 아침 보고서, 정오 보고서, 저녁 보고서 등이 있습니다.

이제 스트리밍을 약간 수정했습니다. 하지만 또 다른 점은 그들의 특정 프롬프트를 사용하고 있다는 것인데, 프롬프트가 상당히 다릅니다.

첨부된 스크린샷이나 UI 모형을 설명하고, 머리글, 바닥글 정보를 제공하고, 스크린샷의 정확한 텍스트를 사용하라는 내용입니다.

보시다시피 텍스트를 추출하고 OCR을 수행하고 있습니다.

페이지에 실제로 무엇이 있는지에 대한 설명을 많이 얻고 있습니다. 여기서 주요 목표는 그것이 아니라고 생각합니다.

OCR이 실제 텍스트만 제공하고 이를 사용할 수 있기를 바랍니다. 하지만 한 가지 기술은 설명을 얻는 단계와 OCR을 얻는 단계를 분리하는 것인데, 이는 매우 유용할 수 있습니다.

자, 두 번째 방법은 여기에 로컬 이미지를 로드하는 것입니다.

여기에는 제가 여러 비디오에서 사용했던 월마트 영수증이 있습니다. 보시다시피 여기서는 이미지에 대한 간단한 프롬프트를 사용하고 있습니다.

이제 이걸 인코딩할 겁니다. 인코딩할 때는 인코딩의 마임 유형이 실제로 인코딩한 것과 일치하는지 확인해야 합니다.

이것은 JPEG 이미지입니다. 여기 아래에 있는 마임 유형도 JPEG 이미지인 것을 알 수 있습니다.

이것이 PNG인 경우 기본적으로 이걸 바꿔야 합니다. 이걸 하기 위해 잠시 후에 저만의 클래스를 만들었습니다.

거기에 모델을 전달하고 스트리밍을 수정합니다. 보시다시피 우리가 얻는 결과는 일관성이 있지만 여전히 일종의 설명이 좀 더 있습니다.

대부분의 정보를 얻고 있는 것 같지만, 우리가 반드시 원하지 않는 이런 종류의 명확한 설명이 있습니다.

좋아요. 제가 하고 싶었던 것은 이 이미지 프로세스를 클래스로 만들고 모델을 전달할 수 있는 자체 편집 버전을 만드는 것이었습니다.

프롬프트를 전달할 수 있습니다. 모델은 기본적으로 여기에서 11B 버전으로 설정됩니다.

또 다른 것은 우리가 입력한 내용을 기반으로 이미지에 대한 올바른 마임 유형을 기본적으로 파악한다는 것입니다.

여기에서 PNG, JPEG, GIF 파일 및 WebP 파일을 지원할 수 있으며 인코딩을 처리합니다.

그런 다음 이걸 전달합니다. 여기에 설정된 프롬프트와 모델을 볼 수 있습니다.

이걸 사용하려면 이미지 프로세서를 인스턴스화하고 프롬프트를 재정의하려면 새 프롬프트를 전달하기만 하면 됩니다.

여기서는 그들이 가지고 있는 시스템 프롬프트를 사용하려고 합니다. 이것은 실제로 LlamaOCR에서 사용한 시스템 프롬프트입니다.

기본적으로 그걸 전달하고 있습니다. 그런 다음 사진을 전달할 수 있습니다. 이건 실제로 존재하지 않습니다.

자, 이걸 테스트해서 문제가 생겼을 때 어떻게 되는지 살펴보고 진행하겠습니다. 보시다시피 영수증의 PNG 버전을 넣어도

문제없이 처리하는 것을 볼 수 있습니다. OCR을 명시적으로 요청했기 때문에 마크다운 출력이 훨씬 더 많이 나타나는 것을 알 수 있습니다.

자, MIME 유형 부분을 테스트해 보겠습니다.

WebP 이미지를 넣어보면 아주 잘 처리하는 것을 볼 수 있습니다. 이것은 제가 앞서 사용했던 이미지입니다.

LlamaOCR - Building your Own Private OCR System

LlamaOCR - Building your Own Private OCR System

스크립트