add files

.dockerignore

@@ -0,0 +1,34 @@
+# Include any files or directories that you don't want to be copied to your
+# container here (e.g., local build artifacts, temporary files, etc.).
+#
+# For more help, visit the .dockerignore file reference guide at
+# https://docs.docker.com/go/build-context-dockerignore/
+
+**/.DS_Store
+**/__pycache__
+**/.venv
+**/.classpath
+**/.dockerignore
+**/.env
+**/.git
+**/.gitignore
+**/.project
+**/.settings
+**/.toolstarget
+**/.vs
+**/.vscode
+**/*.*proj.user
+**/*.dbmdl
+**/*.jfm
+**/bin
+**/charts
+**/docker-compose*
+**/compose*
+**/Dockerfile*
+**/node_modules
+**/npm-debug.log
+**/obj
+**/secrets.dev.yaml
+**/values.dev.yaml
+LICENSE
+README.md

Dockerfile

@@ -0,0 +1,49 @@
+# syntax=docker/dockerfile:1
+
+# Comments are provided throughout this file to help you get started.
+# If you need more help, visit the Dockerfile reference guide at
+# https://docs.docker.com/go/dockerfile-reference/
+
+ARG PYTHON_VERSION=3.11.5
+FROM python:${PYTHON_VERSION}-slim as base
+
+# Prevents Python from writing pyc files.
+ENV PYTHONDONTWRITEBYTECODE=1
+
+# Keeps Python from buffering stdout and stderr to avoid situations where
+# the application crashes without emitting any logs due to buffering.
+ENV PYTHONUNBUFFERED=1
+
+WORKDIR /app
+
+# Create a non-privileged user that the app will run under.
+# See https://docs.docker.com/go/dockerfile-user-best-practices/
+ARG UID=10001
+RUN adduser \
+    --disabled-password \
+    --gecos "" \
+    --home "/nonexistent" \
+    --shell "/sbin/nologin" \
+    --no-create-home \
+    --uid "${UID}" \
+    appuser
+
+# Download dependencies as a separate step to take advantage of Docker's caching.
+# Leverage a cache mount to /root/.cache/pip to speed up subsequent builds.
+# Leverage a bind mount to requirements.txt to avoid having to copy them into
+# into this layer.
+RUN --mount=type=cache,target=/root/.cache/pip \
+    --mount=type=bind,source=requirements.txt,target=requirements.txt \
+    python -m pip install -r requirements.txt
+
+# Switch to the non-privileged user to run the application.
+USER appuser
+
+# Copy the source code into the container.
+COPY . .
+
+# Expose the port that the application listens on.
+EXPOSE 8000
+
+# Run the application.
+CMD streamlit run app.py

README.Docker.md

@@ -0,0 +1,22 @@
+### Building and running your application
+
+When you're ready, start your application by running:
+`docker compose up --build`.
+
+Your application will be available at http://localhost:8000.
+
+### Deploying your application to the cloud
+
+First, build your image, e.g.: `docker build -t myapp .`.
+If your cloud uses a different CPU architecture than your development
+machine (e.g., you are on a Mac M1 and your cloud provider is amd64),
+you'll want to build the image for that platform, e.g.:
+`docker build --platform=linux/amd64 -t myapp .`.
+
+Then, push it to your registry, e.g. `docker push myregistry.com/myapp`.
+
+Consult Docker's [getting started](https://docs.docker.com/go/get-started-sharing/)
+docs for more detail on building and pushing.
+
+### References
+* [Docker's Python guide](https://docs.docker.com/language/python/)

app.css

@@ -0,0 +1,45 @@
+
+/* CSS */
+.button {
+  appearance: button;
+  line-height: 44px;
+  text-decoration: none;
+  color:white !important;
+  backface-visibility: hidden;
+  border-color: #405cf5 !important;
+  background-color: white;
+  color:#405cf5 !important;
+  border-radius: 6px;
+  border-width: 0;
+  box-shadow: rgba(50, 50, 93, .1) 0 0 0 1px inset,rgba(50, 50, 93, .1) 0 2px 5px 0,rgba(0, 0, 0, .07) 0 1px 1px 0;
+  box-sizing: border-box;
+  color: #fff;
+  cursor: pointer;
+  font-family: -apple-system,system-ui,"Segoe UI",Roboto,"Helvetica Neue",Ubuntu,sans-serif;
+  font-size: 100%;
+  height: 44px;
+  /*line-height: 1.15;*/
+  margin: 12px 0 0;
+  outline: none;
+  overflow: hidden;
+  padding: 0 25px;
+  position: relative;
+  text-align: center;
+  text-transform: none;
+  transform: translateZ(0);
+  transition: all .2s,box-shadow .08s ease-in;
+  user-select: none;
+  -webkit-user-select: none;
+  touch-action: manipulation;
+  font-weight: bold;
+  margin:5px;
+}
+
+.button:disabled {
+  cursor: default;
+}
+
+.button:hover {
+    text-decoration: none;
+  box-shadow: rgba(50, 50, 93, .1) 0 0 0 1px inset, rgba(50, 50, 93, .2) 0 6px 15px 0, rgba(0, 0, 0, .1) 0 2px 2px 0, rgba(50, 151, 211, .3) 0 0 0 4px;
+}

app.py

@@ -0,0 +1,186 @@
+
+import streamlit as st
+from PIL import Image
+import os
+import easyocr
+import numpy as np
+import fitz  # PyMuPDF
+import io
+from pdf2image import convert_from_bytes
+from st_btn_group import st_btn_group
+from streamlit_option_menu import option_menu
+import docx
+from docx.shared import Pt
+from io import BytesIO  
+#import streamlit.components.v1 as components
+import base64
+
+#def downloadTxt():
+def generateTxtLink(result):
+    result_txt = ""
+    print(result)
+    for para in result:
+        result_txt += para[1]+"\n"
+    result_b64 = base64.b64encode(result_txt.encode()).decode('utf-8')
+    result_txt_link = "<a class='button' href='data:text/plain;base64,"+result_b64+"' download='document.txt'>TXT</a>"
+    return result_txt_link
+
+def generateMultiPageTxtLink(result):
+    result_txt = ""
+    print(result)
+    for para in result:
+        result_txt += para+"\n"
+    result_b64 = base64.b64encode(result_txt.encode()).decode('utf-8')
+    result_txt_link = "<a class='button' href='data:text/plain;base64,"+result_b64+"' download='document.txt'>TXT</a>"
+    return result_txt_link
+
+def generateDocLink(result):
+    doc = docx.Document()
+    for para in result:
+        doc.add_paragraph(para[1])
+
+    target_stream = BytesIO()
+    result_doc = doc.save(target_stream)
+    base64_doc = base64.b64encode(target_stream.getvalue()).decode('utf-8')
+    stlyeCss = ""
+    doc_link = "<a class='button' href='data:application/pdf;base64,"+base64_doc+"' download='document.docx'>DOCX</a>"
+    return doc_link
+
+def generateMultiPageDocLink(pages_result):
+    doc = docx.Document()
+    #print(pages_result)
+    for page in pages_result:
+        page_split = page.split("\n")
+        for para in page_split:
+            doc.add_paragraph(para)
+        doc.add_page_break()
+    target_stream = BytesIO()
+    result_doc = doc.save(target_stream)
+    base64_doc = base64.b64encode(target_stream.getvalue()).decode('utf-8')
+    doc_link = "<a class='button' href='data:application/pdf;base64,"+base64_doc+"' download='document.docx'>DOCX</a>"
+    return doc_link
+
+def generateButtonGroup(result):
+    txtLink = generateTxtLink(result)
+    docLink = generateDocLink(result)
+    return txtLink+"\n"+docLink
+
+def generateButtonGroupForPDF(pages_result):
+    #result = "\n\n".join(pages_result)
+    txtLink = generateMultiPageTxtLink(pages_result)
+    docLink = generateMultiPageDocLink(pages_result)
+    return txtLink+"\n"+docLink
+
+def local_css(file_name):
+    with open(file_name) as f:
+        st.markdown(f'<style>{f.read()}</style>', unsafe_allow_html=True)
+
+
+models_dir = "./models"
+output_dir = "./output"
+dirs = [models_dir, output_dir]
+for d in dirs:
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+font_path = models_dir + "/Ubuntu-Regular.ttf"
+reader = easyocr.Reader(
+    ['en'],
+    gpu=True,
+    recog_network='best_norm_ED',
+    detect_network="craft",
+    user_network_directory=models_dir,
+    model_storage_directory=models_dir,
+)  # this needs to run only once to load the model into memory
+
+
+
+
+# main title
+st.set_page_config(layout="wide",page_title="Қазақша OCR, суреттегі текстті тану")
+local_css("app.css")
+#st.markdown("<a class='button' href='lenta.ru'>DOCX жүктеп ал</a>",unsafe_allow_html=True)
+st.title("Сурет немесе пдф файлдан текст алу")
+# subtitle
+#st.markdown("## Qazaq OCR")
+
+uploaded_file = st.file_uploader("Өз файлыңызды осында жүктеңіз ('png', 'jpeg', 'jpg', 'pdf')",help="aaa", type=['png', 'jpeg', 'jpg', 'pdf'])
+
+col1, col2 = st.columns(2)
+
+#def process_page(page):
+#    image_matrix = fitz.Matrix(fitz.Identity)
+#    pixmap = page.get_pixmap(matrix=image_matrix, dpi=300)
+#    image_data = pixmap.samples# This is a bytes object
+#    image = Image.from("RGB",(pixmap.width, pixmap.height),image_data)
+#    image =  Image.from("RGB", (pixmap.width, pixmap.height), image_data)
+#    result = reader.readtext(np.array(image),paragraph=True)
+#    return image, result 
+import time
+
+max_page = 3
+def recognize_page_image(image):
+    start = time.time()
+    result = [[0,"Sample 1"],[1,"Sample 2"]]
+    result = reader.readtext(np.array(image), paragraph=True)
+    end = time.time()
+    return result,(end-start)
+
+
+def process_pdf(uploaded_file):
+    pdf_document = fitz.open(temp_pdf_file)
+    total_pages = len(pdf_document)
+    progress_bar = col2.progress(0, text="Жүктеліп жатыр")
+    button_group = col2.container()
+    pages = range(min(max_page,total_pages))
+    tabs = col1.tabs([f"Бет {page+1}" for page in pages])
+    pages_result = []
+    for count, page_num in enumerate(range(min(total_pages,max_page))):
+        page = pdf_document.load_page(page_num)
+        image_matrix = fitz.Matrix(fitz.Identity)
+        pixmap = page.get_pixmap(matrix=image_matrix, dpi=300)
+        image_data = pixmap.samples  # This is a bytes object
+        image = Image.frombytes("RGB", (pixmap.width, pixmap.height), image_data)
+        imageSmaller = image.resize((int(pixmap.width/10), int(pixmap.height/10)))
+        tabs[count].image(imageSmaller)
+        #buffered = BytesIO()
+        #imageSmaller.save(buffered,format="JPEG")
+        #col1.write(f'<h2>Бет {page_num + 1}/{total_pages}</h2>',unsafe_allow_html=True)
+        #col1.write(f'<img src="data:image/png;base64, {base64.b64encode(buffered.getvalue()).decode("utf-8")}"/>',unsafe_allow_html=True)
+        #col1.subheader(f'Бет {page_num + 1}/{total_pages}')
+        #col1.image(imageSmaller, caption=f'Бет {page_num + 1}')
+        result,time_elapsed = recognize_page_image(image)
+        expander = col2.expander(f'{result[0][1][:100]} ... **:orange[{time_elapsed:.3f} секундта таңылды]**')
+        expander.write(f'{result[0][1]}')
+        result_text = "\n\n".join([item[1] for item in result])
+        pages_result.append(result_text)
+        #col2.markdown(result_text)
+        progress_bar.progress((count + 1) / min(total_pages,max_page),text=f'Жүктеліп жатыр {count+1}/{min(total_pages,max_page)}')
+    
+    button_group_html = generateButtonGroupForPDF(pages_result)
+    button_group.write(button_group_html,unsafe_allow_html=True)
+    #col1.write("</div>",unsafe_allow_html=True)
+    progress_bar.progress(0.99,text=f'{min(total_pages,max_page)} бет жүктелді')
+    
+
+
+if uploaded_file is not None:
+    if uploaded_file.type == "application/pdf":
+        placeholder = col2.empty()
+        with placeholder, st.spinner('PDF өңделуде ...'):
+            temp_pdf_file = "./temp_pdf_file.pdf"
+            with open(temp_pdf_file, "wb") as f:
+                f.write(uploaded_file.read())
+            process_pdf(uploaded_file)
+    else:
+        placeholder = col2.empty()
+        with placeholder,st.spinner('Сурет өңделуде ...'):
+            image = Image.open(uploaded_file)
+            #with open(os.path.join("tempDir",image_file))
+            col1.image(image)
+            result = reader.readtext(np.array(image), paragraph=True)
+            result_text = "\n\n".join([item[1] for item in result])
+            button_group_html = generateButtonGroup(result)
+            col2.write(button_group_html, unsafe_allow_html=True)
+            col2.markdown(result_text)
+        

compose.yaml

@@ -0,0 +1,49 @@
+# Comments are provided throughout this file to help you get started.
+# If you need more help, visit the Docker compose reference guide at
+# https://docs.docker.com/go/compose-spec-reference/
+
+# Here the instructions define your application as a service called "server".
+# This service is built from the Dockerfile in the current directory.
+# You can add other services your application may depend on here, such as a
+# database or a cache. For examples, see the Awesome Compose repository:
+# https://github.com/docker/awesome-compose
+services:
+  server:
+    build:
+      context: .
+    ports:
+      - 8000:8000
+
+# The commented out section below is an example of how to define a PostgreSQL
+# database that your application can use. `depends_on` tells Docker Compose to
+# start the database before your application. The `db-data` volume persists the
+# database data between container restarts. The `db-password` secret is used
+# to set the database password. You must create `db/password.txt` and add
+# a password of your choosing to it before running `docker compose up`.
+#     depends_on:
+#       db:
+#         condition: service_healthy
+#   db:
+#     image: postgres
+#     restart: always
+#     user: postgres
+#     secrets:
+#       - db-password
+#     volumes:
+#       - db-data:/var/lib/postgresql/data
+#     environment:
+#       - POSTGRES_DB=example
+#       - POSTGRES_PASSWORD_FILE=/run/secrets/db-password
+#     expose:
+#       - 5432
+#     healthcheck:
+#       test: [ "CMD", "pg_isready" ]
+#       interval: 10s
+#       timeout: 5s
+#       retries: 5
+# volumes:
+#   db-data:
+# secrets:
+#   db-password:
+#     file: db/password.txt
+

custom_shape.py

@@ -0,0 +1,35 @@
+import streamlit as st
+import cv2
+import numpy as np
+from PIL import Image
+
+def warp_perspective(image, points):
+    # Input and output dimensions
+    w, h = 300, 400  # You can adjust this based on the desired output size
+    input_pts = np.array(points, dtype=np.float32)
+    output_pts = np.array([[0, 0], [w, 0], [w, h], [0, h]], dtype=np.float32)
+    
+    # Compute perspective matrix and warp the image
+    matrix = cv2.getPerspectiveTransform(input_pts, output_pts)
+    warped_img = cv2.warpPerspective(image, matrix, (w, h))
+    
+    return warped_img
+
+st.title("Custom Shape Cropping & Perspective Correction")
+
+uploaded_file = st.file_uploader("Upload an image", type=["jpg", "jpeg", "png"])
+
+# Provide a placeholder for the user to input 4 vertices
+points = []
+for i in range(4):
+    coords = st.text_input(f"Enter point {i+1} (format: x,y)", "")
+    x, y = map(int, coords.split(',')) if ',' in coords else (0, 0)
+    points.append([x, y])
+
+if uploaded_file and len(points) == 4:
+    image = Image.open(uploaded_file).convert('RGB')
+    image_np = np.array(image)
+    
+    corrected_image = warp_perspective(image_np, points)
+    
+    st.image(corrected_image, caption='Corrected Image.', channels="BGR", use_column_width=True)

kz_ocr_easy.py

@@ -0,0 +1,88 @@
+import os
+import cv2
+import numpy as np
+from PIL import Image, ImageDraw, ImageFont
+from tqdm import tqdm
+import os
+
+import easyocr
+
+models_dir = "./models"
+images_dir = "./images"
+output_dir = "./output"
+dirs = [models_dir, images_dir, output_dir]
+for d in dirs:
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+"""
+Upload easy OCR model files with the same name and font file named Ubuntu-Regular.ttf, examples:
+best_norm_ED.pth
+best_norm_ED.py
+best_norm_ED.yaml
+Ubuntu-Regular.ttf
+
+to models directory
+
+Upload image files you want to test, examples:
+kz_book_simple.jpeg
+kz_blur.jpg
+kz_book_complex.jpg
+
+to images directory
+"""
+
+font_path = models_dir + "/Ubuntu-Regular.ttf"
+
+reader = easyocr.Reader(
+    ['en'],
+    gpu=True,
+    recog_network='best_norm_ED',
+    detect_network="craft",
+    user_network_directory=models_dir,
+    model_storage_directory=models_dir,
+)  # this needs to run only once to load the model into memory
+
+image_extensions = (".jpg", ".jpeg", ".png")
+
+for image_name in tqdm(os.listdir(images_dir)):
+    if not image_name.lower().endswith(image_extensions):
+        print(f'unsupported file {image_name}')
+        continue
+    image_path = f'{images_dir}/{image_name}'
+    print(image_path)
+    # Read image as numpy array
+    image = cv2.imread(image_path)
+
+    # Rotate the image by 270 degrees
+    # image = cv2.rotate(image, cv2.ROTATE_90_CLOCKWISE)
+
+    # Convert the image from BGR to RGB (because OpenCV loads images in BGR format)
+    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+    results = reader.readtext(image=image)
+
+    # Load custom font
+    font = ImageFont.truetype(font_path, 32)
+
+    # Display the results
+    for (bbox, text, prob) in results:
+        # Get the bounding box coordinates
+        (top_left, top_right, bottom_right, bottom_left) = bbox
+        top_left = (int(top_left[0]), int(top_left[1]))
+        bottom_right = (int(bottom_right[0]), int(bottom_right[1]))
+
+        # Draw the bounding box on the image
+        cv2.rectangle(image, top_left, bottom_right, (0, 255, 0), 2)
+
+        # Convert the OpenCV image to a PIL image, draw the text, then convert back to an OpenCV image
+        image_pil = Image.fromarray(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
+        draw = ImageDraw.Draw(image_pil)
+        draw.text((top_left[0], top_left[1] - 40), text, font=font, fill=(0, 0, 255))
+        image = cv2.cvtColor(np.array(image_pil), cv2.COLOR_RGB2BGR)
+
+    # Save image
+    cv2.imwrite( f'{output_dir}/{image_name}', image)
+
+    # reader.readtext(image = image, paragraph=True)
+
+

models/best_norm_ED.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fd58f2bb4ac8afece8d5e6a988c390ec5586152b214aa0906127ccfbdcc71961
+size 15217067

models/best_norm_ED.py

@@ -0,0 +1,538 @@
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+
+class TPS_SpatialTransformerNetwork(nn.Module):
+    """ Rectification Network of RARE, namely TPS based STN """
+
+    def __init__(self, F, I_size, I_r_size, I_channel_num=1):
+        """ Based on RARE TPS
+        input:
+            batch_I: Batch Input Image [batch_size x I_channel_num x I_height x I_width]
+            I_size : (height, width) of the input image I
+            I_r_size : (height, width) of the rectified image I_r
+            I_channel_num : the number of channels of the input image I
+        output:
+            batch_I_r: rectified image [batch_size x I_channel_num x I_r_height x I_r_width]
+        """
+        super(TPS_SpatialTransformerNetwork, self).__init__()
+        self.F = F
+        self.I_size = I_size
+        self.I_r_size = I_r_size  # = (I_r_height, I_r_width)
+        self.I_channel_num = I_channel_num
+        self.LocalizationNetwork = LocalizationNetwork(self.F, self.I_channel_num)
+        self.GridGenerator = GridGenerator(self.F, self.I_r_size)
+
+    def forward(self, batch_I):
+        batch_C_prime = self.LocalizationNetwork(batch_I)  # batch_size x K x 2
+        build_P_prime = self.GridGenerator.build_P_prime(batch_C_prime)  # batch_size x n (= I_r_width x I_r_height) x 2
+        build_P_prime_reshape = build_P_prime.reshape([build_P_prime.size(0), self.I_r_size[0], self.I_r_size[1], 2])
+        batch_I_r = F.grid_sample(batch_I, build_P_prime_reshape, padding_mode='border')
+
+        return batch_I_r
+
+
+class LocalizationNetwork(nn.Module):
+    """ Localization Network of RARE, which predicts C' (K x 2) from I (I_width x I_height) """
+
+    def __init__(self, F, I_channel_num):
+        super(LocalizationNetwork, self).__init__()
+        self.F = F
+        self.I_channel_num = I_channel_num
+        self.conv = nn.Sequential(
+            nn.Conv2d(in_channels=self.I_channel_num, out_channels=64, kernel_size=3, stride=1, padding=1,
+                      bias=False), nn.BatchNorm2d(64), nn.ReLU(True),
+            nn.MaxPool2d(2, 2),  # batch_size x 64 x I_height/2 x I_width/2
+            nn.Conv2d(64, 128, 3, 1, 1, bias=False), nn.BatchNorm2d(128), nn.ReLU(True),
+            nn.MaxPool2d(2, 2),  # batch_size x 128 x I_height/4 x I_width/4
+            nn.Conv2d(128, 256, 3, 1, 1, bias=False), nn.BatchNorm2d(256), nn.ReLU(True),
+            nn.MaxPool2d(2, 2),  # batch_size x 256 x I_height/8 x I_width/8
+            nn.Conv2d(256, 512, 3, 1, 1, bias=False), nn.BatchNorm2d(512), nn.ReLU(True),
+            nn.AdaptiveAvgPool2d(1)  # batch_size x 512
+        )
+
+        self.localization_fc1 = nn.Sequential(nn.Linear(512, 256), nn.ReLU(True))
+        self.localization_fc2 = nn.Linear(256, self.F * 2)
+
+        # Init fc2 in LocalizationNetwork
+        self.localization_fc2.weight.data.fill_(0)
+        """ see RARE paper Fig. 6 (a) """
+        ctrl_pts_x = np.linspace(-1.0, 1.0, int(F / 2))
+        ctrl_pts_y_top = np.linspace(0.0, -1.0, num=int(F / 2))
+        ctrl_pts_y_bottom = np.linspace(1.0, 0.0, num=int(F / 2))
+        ctrl_pts_top = np.stack([ctrl_pts_x, ctrl_pts_y_top], axis=1)
+        ctrl_pts_bottom = np.stack([ctrl_pts_x, ctrl_pts_y_bottom], axis=1)
+        initial_bias = np.concatenate([ctrl_pts_top, ctrl_pts_bottom], axis=0)
+        self.localization_fc2.bias.data = torch.from_numpy(initial_bias).float().view(-1)
+
+    def forward(self, batch_I):
+        """
+        input:     batch_I : Batch Input Image [batch_size x I_channel_num x I_height x I_width]
+        output:    batch_C_prime : Predicted coordinates of fiducial points for input batch [batch_size x F x 2]
+        """
+        batch_size = batch_I.size(0)
+        features = self.conv(batch_I).view(batch_size, -1)
+        batch_C_prime = self.localization_fc2(self.localization_fc1(features)).view(batch_size, self.F, 2)
+        return batch_C_prime
+
+
+class GridGenerator(nn.Module):
+    """ Grid Generator of RARE, which produces P_prime by multiplying T with P """
+
+    def __init__(self, F, I_r_size):
+        """ Generate P_hat and inv_delta_C for later """
+        super(GridGenerator, self).__init__()
+        self.eps = 1e-6
+        self.I_r_height, self.I_r_width = I_r_size
+        self.F = F
+        self.C = self._build_C(self.F)  # F x 2
+        self.P = self._build_P(self.I_r_width, self.I_r_height)
+        ## for multi-gpu, you need register buffer
+        self.register_buffer("inv_delta_C", torch.tensor(self._build_inv_delta_C(self.F, self.C)).float())  # F+3 x F+3
+        self.register_buffer("P_hat", torch.tensor(self._build_P_hat(self.F, self.C, self.P)).float())  # n x F+3
+        ## for fine-tuning with different image width, you may use below instead of self.register_buffer
+        # self.inv_delta_C = torch.tensor(self._build_inv_delta_C(self.F, self.C)).float().cuda()  # F+3 x F+3
+        # self.P_hat = torch.tensor(self._build_P_hat(self.F, self.C, self.P)).float().cuda()  # n x F+3
+
+    def _build_C(self, F):
+        """ Return coordinates of fiducial points in I_r; C """
+        ctrl_pts_x = np.linspace(-1.0, 1.0, int(F / 2))
+        ctrl_pts_y_top = -1 * np.ones(int(F / 2))
+        ctrl_pts_y_bottom = np.ones(int(F / 2))
+        ctrl_pts_top = np.stack([ctrl_pts_x, ctrl_pts_y_top], axis=1)
+        ctrl_pts_bottom = np.stack([ctrl_pts_x, ctrl_pts_y_bottom], axis=1)
+        C = np.concatenate([ctrl_pts_top, ctrl_pts_bottom], axis=0)
+        return C  # F x 2
+
+    def _build_inv_delta_C(self, F, C):
+        """ Return inv_delta_C which is needed to calculate T """
+        hat_C = np.zeros((F, F), dtype=float)  # F x F
+        for i in range(0, F):
+            for j in range(i, F):
+                r = np.linalg.norm(C[i] - C[j])
+                hat_C[i, j] = r
+                hat_C[j, i] = r
+        np.fill_diagonal(hat_C, 1)
+        hat_C = (hat_C ** 2) * np.log(hat_C)
+        # print(C.shape, hat_C.shape)
+        delta_C = np.concatenate(  # F+3 x F+3
+            [
+                np.concatenate([np.ones((F, 1)), C, hat_C], axis=1),  # F x F+3
+                np.concatenate([np.zeros((2, 3)), np.transpose(C)], axis=1),  # 2 x F+3
+                np.concatenate([np.zeros((1, 3)), np.ones((1, F))], axis=1)  # 1 x F+3
+            ],
+            axis=0
+        )
+        inv_delta_C = np.linalg.inv(delta_C)
+        return inv_delta_C  # F+3 x F+3
+
+    def _build_P(self, I_r_width, I_r_height):
+        I_r_grid_x = (np.arange(-I_r_width, I_r_width, 2) + 1.0) / I_r_width  # self.I_r_width
+        I_r_grid_y = (np.arange(-I_r_height, I_r_height, 2) + 1.0) / I_r_height  # self.I_r_height
+        P = np.stack(  # self.I_r_width x self.I_r_height x 2
+            np.meshgrid(I_r_grid_x, I_r_grid_y),
+            axis=2
+        )
+        return P.reshape([-1, 2])  # n (= self.I_r_width x self.I_r_height) x 2
+
+    def _build_P_hat(self, F, C, P):
+        n = P.shape[0]  # n (= self.I_r_width x self.I_r_height)
+        P_tile = np.tile(np.expand_dims(P, axis=1), (1, F, 1))  # n x 2 -> n x 1 x 2 -> n x F x 2
+        C_tile = np.expand_dims(C, axis=0)  # 1 x F x 2
+        P_diff = P_tile - C_tile  # n x F x 2
+        rbf_norm = np.linalg.norm(P_diff, ord=2, axis=2, keepdims=False)  # n x F
+        rbf = np.multiply(np.square(rbf_norm), np.log(rbf_norm + self.eps))  # n x F
+        P_hat = np.concatenate([np.ones((n, 1)), P, rbf], axis=1)
+        return P_hat  # n x F+3
+
+    def build_P_prime(self, batch_C_prime):
+        """ Generate Grid from batch_C_prime [batch_size x F x 2] """
+        batch_size = batch_C_prime.size(0)
+        batch_inv_delta_C = self.inv_delta_C.repeat(batch_size, 1, 1)
+        batch_P_hat = self.P_hat.repeat(batch_size, 1, 1)
+        batch_C_prime_with_zeros = torch.cat((batch_C_prime, torch.zeros(
+            batch_size, 3, 2).float().to(device)), dim=1)  # batch_size x F+3 x 2
+        batch_T = torch.bmm(batch_inv_delta_C, batch_C_prime_with_zeros)  # batch_size x F+3 x 2
+        batch_P_prime = torch.bmm(batch_P_hat, batch_T)  # batch_size x n x 2
+        return batch_P_prime  # batch_size x n x 2
+
+
+class VGG_FeatureExtractor(nn.Module):
+    """ FeatureExtractor of CRNN (https://arxiv.org/pdf/1507.05717.pdf) """
+
+    def __init__(self, input_channel, output_channel=512):
+        super(VGG_FeatureExtractor, self).__init__()
+        self.output_channel = [int(output_channel / 8), int(output_channel / 4),
+                               int(output_channel / 2), output_channel]  # [64, 128, 256, 512]
+        self.ConvNet = nn.Sequential(
+            nn.Conv2d(input_channel, self.output_channel[0], 3, 1, 1), nn.ReLU(True),
+            nn.MaxPool2d(2, 2),  # 64x16x50
+            nn.Conv2d(self.output_channel[0], self.output_channel[1], 3, 1, 1), nn.ReLU(True),
+            nn.MaxPool2d(2, 2),  # 128x8x25
+            nn.Conv2d(self.output_channel[1], self.output_channel[2], 3, 1, 1), nn.ReLU(True),  # 256x8x25
+            nn.Conv2d(self.output_channel[2], self.output_channel[2], 3, 1, 1), nn.ReLU(True),
+            nn.MaxPool2d((2, 1), (2, 1)),  # 256x4x25
+            nn.Conv2d(self.output_channel[2], self.output_channel[3], 3, 1, 1, bias=False),
+            nn.BatchNorm2d(self.output_channel[3]), nn.ReLU(True),  # 512x4x25
+            nn.Conv2d(self.output_channel[3], self.output_channel[3], 3, 1, 1, bias=False),
+            nn.BatchNorm2d(self.output_channel[3]), nn.ReLU(True),
+            nn.MaxPool2d((2, 1), (2, 1)),  # 512x2x25
+            nn.Conv2d(self.output_channel[3], self.output_channel[3], 2, 1, 0), nn.ReLU(True))  # 512x1x24
+
+    def forward(self, input):
+        return self.ConvNet(input)
+
+
+class RCNN_FeatureExtractor(nn.Module):
+    """ FeatureExtractor of GRCNN (https://papers.nips.cc/paper/6637-gated-recurrent-convolution-neural-network-for-ocr.pdf) """
+
+    def __init__(self, input_channel, output_channel=512):
+        super(RCNN_FeatureExtractor, self).__init__()
+        self.output_channel = [int(output_channel / 8), int(output_channel / 4),
+                               int(output_channel / 2), output_channel]  # [64, 128, 256, 512]
+        self.ConvNet = nn.Sequential(
+            nn.Conv2d(input_channel, self.output_channel[0], 3, 1, 1), nn.ReLU(True),
+            nn.MaxPool2d(2, 2),  # 64 x 16 x 50
+            GRCL(self.output_channel[0], self.output_channel[0], num_iteration=5, kernel_size=3, pad=1),
+            nn.MaxPool2d(2, 2),  # 64 x 8 x 25
+            GRCL(self.output_channel[0], self.output_channel[1], num_iteration=5, kernel_size=3, pad=1),
+            nn.MaxPool2d(2, (2, 1), (0, 1)),  # 128 x 4 x 26
+            GRCL(self.output_channel[1], self.output_channel[2], num_iteration=5, kernel_size=3, pad=1),
+            nn.MaxPool2d(2, (2, 1), (0, 1)),  # 256 x 2 x 27
+            nn.Conv2d(self.output_channel[2], self.output_channel[3], 2, 1, 0, bias=False),
+            nn.BatchNorm2d(self.output_channel[3]), nn.ReLU(True))  # 512 x 1 x 26
+
+    def forward(self, input):
+        return self.ConvNet(input)
+
+
+class ResNet_FeatureExtractor(nn.Module):
+    """ FeatureExtractor of FAN (http://openaccess.thecvf.com/content_ICCV_2017/papers/Cheng_Focusing_Attention_Towards_ICCV_2017_paper.pdf) """
+
+    def __init__(self, input_channel, output_channel=512):
+        super(ResNet_FeatureExtractor, self).__init__()
+        self.ConvNet = ResNet(input_channel, output_channel, BasicBlock, [1, 2, 5, 3])
+
+    def forward(self, input):
+        return self.ConvNet(input)
+
+
+# For Gated RCNN
+class GRCL(nn.Module):
+
+    def __init__(self, input_channel, output_channel, num_iteration, kernel_size, pad):
+        super(GRCL, self).__init__()
+        self.wgf_u = nn.Conv2d(input_channel, output_channel, 1, 1, 0, bias=False)
+        self.wgr_x = nn.Conv2d(output_channel, output_channel, 1, 1, 0, bias=False)
+        self.wf_u = nn.Conv2d(input_channel, output_channel, kernel_size, 1, pad, bias=False)
+        self.wr_x = nn.Conv2d(output_channel, output_channel, kernel_size, 1, pad, bias=False)
+
+        self.BN_x_init = nn.BatchNorm2d(output_channel)
+
+        self.num_iteration = num_iteration
+        self.GRCL = [GRCL_unit(output_channel) for _ in range(num_iteration)]
+        self.GRCL = nn.Sequential(*self.GRCL)
+
+    def forward(self, input):
+        """ The input of GRCL is consistant over time t, which is denoted by u(0)
+        thus wgf_u / wf_u is also consistant over time t.
+        """
+        wgf_u = self.wgf_u(input)
+        wf_u = self.wf_u(input)
+        x = F.relu(self.BN_x_init(wf_u))
+
+        for i in range(self.num_iteration):
+            x = self.GRCL[i](wgf_u, self.wgr_x(x), wf_u, self.wr_x(x))
+
+        return x
+
+
+class GRCL_unit(nn.Module):
+
+    def __init__(self, output_channel):
+        super(GRCL_unit, self).__init__()
+        self.BN_gfu = nn.BatchNorm2d(output_channel)
+        self.BN_grx = nn.BatchNorm2d(output_channel)
+        self.BN_fu = nn.BatchNorm2d(output_channel)
+        self.BN_rx = nn.BatchNorm2d(output_channel)
+        self.BN_Gx = nn.BatchNorm2d(output_channel)
+
+    def forward(self, wgf_u, wgr_x, wf_u, wr_x):
+        G_first_term = self.BN_gfu(wgf_u)
+        G_second_term = self.BN_grx(wgr_x)
+        G = F.sigmoid(G_first_term + G_second_term)
+
+        x_first_term = self.BN_fu(wf_u)
+        x_second_term = self.BN_Gx(self.BN_rx(wr_x) * G)
+        x = F.relu(x_first_term + x_second_term)
+
+        return x
+
+
+class BasicBlock(nn.Module):
+    expansion = 1
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None):
+        super(BasicBlock, self).__init__()
+        self.conv1 = self._conv3x3(inplanes, planes)
+        self.bn1 = nn.BatchNorm2d(planes)
+        self.conv2 = self._conv3x3(planes, planes)
+        self.bn2 = nn.BatchNorm2d(planes)
+        self.relu = nn.ReLU(inplace=True)
+        self.downsample = downsample
+        self.stride = stride
+
+    def _conv3x3(self, in_planes, out_planes, stride=1):
+        "3x3 convolution with padding"
+        return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,
+                         padding=1, bias=False)
+
+    def forward(self, x):
+        residual = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+
+        if self.downsample is not None:
+            residual = self.downsample(x)
+        out += residual
+        out = self.relu(out)
+
+        return out
+
+
+class ResNet(nn.Module):
+
+    def __init__(self, input_channel, output_channel, block, layers):
+        super(ResNet, self).__init__()
+
+        self.output_channel_block = [int(output_channel / 4), int(output_channel / 2), output_channel, output_channel]
+
+        self.inplanes = int(output_channel / 8)
+        self.conv0_1 = nn.Conv2d(input_channel, int(output_channel / 16),
+                                 kernel_size=3, stride=1, padding=1, bias=False)
+        self.bn0_1 = nn.BatchNorm2d(int(output_channel / 16))
+        self.conv0_2 = nn.Conv2d(int(output_channel / 16), self.inplanes,
+                                 kernel_size=3, stride=1, padding=1, bias=False)
+        self.bn0_2 = nn.BatchNorm2d(self.inplanes)
+        self.relu = nn.ReLU(inplace=True)
+
+        self.maxpool1 = nn.MaxPool2d(kernel_size=2, stride=2, padding=0)
+        self.layer1 = self._make_layer(block, self.output_channel_block[0], layers[0])
+        self.conv1 = nn.Conv2d(self.output_channel_block[0], self.output_channel_block[
+            0], kernel_size=3, stride=1, padding=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(self.output_channel_block[0])
+
+        self.maxpool2 = nn.MaxPool2d(kernel_size=2, stride=2, padding=0)
+        self.layer2 = self._make_layer(block, self.output_channel_block[1], layers[1], stride=1)
+        self.conv2 = nn.Conv2d(self.output_channel_block[1], self.output_channel_block[
+            1], kernel_size=3, stride=1, padding=1, bias=False)
+        self.bn2 = nn.BatchNorm2d(self.output_channel_block[1])
+
+        self.maxpool3 = nn.MaxPool2d(kernel_size=2, stride=(2, 1), padding=(0, 1))
+        self.layer3 = self._make_layer(block, self.output_channel_block[2], layers[2], stride=1)
+        self.conv3 = nn.Conv2d(self.output_channel_block[2], self.output_channel_block[
+            2], kernel_size=3, stride=1, padding=1, bias=False)
+        self.bn3 = nn.BatchNorm2d(self.output_channel_block[2])
+
+        self.layer4 = self._make_layer(block, self.output_channel_block[3], layers[3], stride=1)
+        self.conv4_1 = nn.Conv2d(self.output_channel_block[3], self.output_channel_block[
+            3], kernel_size=2, stride=(2, 1), padding=(0, 1), bias=False)
+        self.bn4_1 = nn.BatchNorm2d(self.output_channel_block[3])
+        self.conv4_2 = nn.Conv2d(self.output_channel_block[3], self.output_channel_block[
+            3], kernel_size=2, stride=1, padding=0, bias=False)
+        self.bn4_2 = nn.BatchNorm2d(self.output_channel_block[3])
+
+    def _make_layer(self, block, planes, blocks, stride=1):
+        downsample = None
+        if stride != 1 or self.inplanes != planes * block.expansion:
+            downsample = nn.Sequential(
+                nn.Conv2d(self.inplanes, planes * block.expansion,
+                          kernel_size=1, stride=stride, bias=False),
+                nn.BatchNorm2d(planes * block.expansion),
+            )
+
+        layers = []
+        layers.append(block(self.inplanes, planes, stride, downsample))
+        self.inplanes = planes * block.expansion
+        for i in range(1, blocks):
+            layers.append(block(self.inplanes, planes))
+
+        return nn.Sequential(*layers)
+
+    def forward(self, x):
+        x = self.conv0_1(x)
+        x = self.bn0_1(x)
+        x = self.relu(x)
+        x = self.conv0_2(x)
+        x = self.bn0_2(x)
+        x = self.relu(x)
+
+        x = self.maxpool1(x)
+        x = self.layer1(x)
+        x = self.conv1(x)
+        x = self.bn1(x)
+        x = self.relu(x)
+
+        x = self.maxpool2(x)
+        x = self.layer2(x)
+        x = self.conv2(x)
+        x = self.bn2(x)
+        x = self.relu(x)
+
+        x = self.maxpool3(x)
+        x = self.layer3(x)
+        x = self.conv3(x)
+        x = self.bn3(x)
+        x = self.relu(x)
+
+        x = self.layer4(x)
+        x = self.conv4_1(x)
+        x = self.bn4_1(x)
+        x = self.relu(x)
+        x = self.conv4_2(x)
+        x = self.bn4_2(x)
+        x = self.relu(x)
+
+        return x
+
+
+class BidirectionalLSTM(nn.Module):
+
+    def __init__(self, input_size, hidden_size, output_size):
+        super(BidirectionalLSTM, self).__init__()
+        self.rnn = nn.LSTM(input_size, hidden_size, bidirectional=True, batch_first=True)
+        self.linear = nn.Linear(hidden_size * 2, output_size)
+
+    def forward(self, input):
+        """
+        input : visual feature [batch_size x T x input_size]
+        output : contextual feature [batch_size x T x output_size]
+        """
+        try:
+            self.rnn.flatten_parameters()
+        except:
+            pass
+        recurrent, _ = self.rnn(input)  # batch_size x T x input_size -> batch_size x T x (2*hidden_size)
+        output = self.linear(recurrent)  # batch_size x T x output_size
+        return output
+
+
+class Attention(nn.Module):
+
+    def __init__(self, input_size, hidden_size, num_classes):
+        super(Attention, self).__init__()
+        self.attention_cell = AttentionCell(input_size, hidden_size, num_classes)
+        self.hidden_size = hidden_size
+        self.num_classes = num_classes
+        self.generator = nn.Linear(hidden_size, num_classes)
+
+    def _char_to_onehot(self, input_char, onehot_dim=38):
+        input_char = input_char.unsqueeze(1)
+        batch_size = input_char.size(0)
+        one_hot = torch.FloatTensor(batch_size, onehot_dim).zero_().to(device)
+        one_hot = one_hot.scatter_(1, input_char, 1)
+        return one_hot
+
+    def forward(self, batch_H, text, is_train=True, batch_max_length=25):
+        """
+        input:
+            batch_H : contextual_feature H = hidden state of encoder. [batch_size x num_steps x num_classes]
+            text : the text-index of each image. [batch_size x (max_length+1)]. +1 for [GO] token. text[:, 0] = [GO].
+        output: probability distribution at each step [batch_size x num_steps x num_classes]
+        """
+        batch_size = batch_H.size(0)
+        num_steps = batch_max_length + 1  # +1 for [s] at end of sentence.
+
+        output_hiddens = torch.FloatTensor(batch_size, num_steps, self.hidden_size).fill_(0).to(device)
+        hidden = (torch.FloatTensor(batch_size, self.hidden_size).fill_(0).to(device),
+                  torch.FloatTensor(batch_size, self.hidden_size).fill_(0).to(device))
+
+        if is_train:
+            for i in range(num_steps):
+                # one-hot vectors for a i-th char. in a batch
+                char_onehots = self._char_to_onehot(text[:, i], onehot_dim=self.num_classes)
+                # hidden : decoder's hidden s_{t-1}, batch_H : encoder's hidden H, char_onehots : one-hot(y_{t-1})
+                hidden, alpha = self.attention_cell(hidden, batch_H, char_onehots)
+                output_hiddens[:, i, :] = hidden[0]  # LSTM hidden index (0: hidden, 1: Cell)
+            probs = self.generator(output_hiddens)
+
+        else:
+            targets = torch.LongTensor(batch_size).fill_(0).to(device)  # [GO] token
+            probs = torch.FloatTensor(batch_size, num_steps, self.num_classes).fill_(0).to(device)
+
+            for i in range(num_steps):
+                char_onehots = self._char_to_onehot(targets, onehot_dim=self.num_classes)
+                hidden, alpha = self.attention_cell(hidden, batch_H, char_onehots)
+                probs_step = self.generator(hidden[0])
+                probs[:, i, :] = probs_step
+                _, next_input = probs_step.max(1)
+                targets = next_input
+
+        return probs  # batch_size x num_steps x num_classes
+
+
+class AttentionCell(nn.Module):
+
+    def __init__(self, input_size, hidden_size, num_embeddings):
+        super(AttentionCell, self).__init__()
+        self.i2h = nn.Linear(input_size, hidden_size, bias=False)
+        self.h2h = nn.Linear(hidden_size, hidden_size)  # either i2i or h2h should have bias
+        self.score = nn.Linear(hidden_size, 1, bias=False)
+        self.rnn = nn.LSTMCell(input_size + num_embeddings, hidden_size)
+        self.hidden_size = hidden_size
+
+    def forward(self, prev_hidden, batch_H, char_onehots):
+        # [batch_size x num_encoder_step x num_channel] -> [batch_size x num_encoder_step x hidden_size]
+        batch_H_proj = self.i2h(batch_H)
+        prev_hidden_proj = self.h2h(prev_hidden[0]).unsqueeze(1)
+        e = self.score(torch.tanh(batch_H_proj + prev_hidden_proj))  # batch_size x num_encoder_step * 1
+
+        alpha = F.softmax(e, dim=1)
+        context = torch.bmm(alpha.permute(0, 2, 1), batch_H).squeeze(1)  # batch_size x num_channel
+        concat_context = torch.cat([context, char_onehots], 1)  # batch_size x (num_channel + num_embedding)
+        cur_hidden = self.rnn(concat_context, prev_hidden)
+        return cur_hidden, alpha
+
+
+class Model(nn.Module):
+
+    def __init__(self, input_channel, output_channel, hidden_size, num_class):
+        super(Model, self).__init__()
+
+
+        """ FeatureExtraction """
+        self.FeatureExtraction = VGG_FeatureExtractor(input_channel, output_channel)
+        self.FeatureExtraction_output = output_channel  # int(imgH/16-1) * 512
+        self.AdaptiveAvgPool = nn.AdaptiveAvgPool2d((None, 1))  # Transform final (imgH/16-1) -> 1
+
+        """ Sequence modeling"""
+        self.SequenceModeling = nn.Sequential(
+            BidirectionalLSTM(self.FeatureExtraction_output, hidden_size, hidden_size),
+            BidirectionalLSTM(hidden_size, hidden_size, hidden_size))
+        self.SequenceModeling_output = hidden_size
+
+
+        self.Prediction = nn.Linear(self.SequenceModeling_output, num_class)
+
+    def forward(self, input, text):
+
+        """ Feature extraction stage """
+        visual_feature = self.FeatureExtraction(input)
+        visual_feature = self.AdaptiveAvgPool(visual_feature.permute(0, 3, 1, 2))  # [b, c, h, w] -> [b, w, c, h]
+        visual_feature = visual_feature.squeeze(3)
+
+        """ Sequence modeling stage """
+        contextual_feature = self.SequenceModeling(visual_feature)
+
+        prediction = self.Prediction(contextual_feature.contiguous())
+
+        return prediction

models/best_norm_ED.yaml

@@ -0,0 +1,52 @@
+number: '0123456789'
+symbol: "!?.,:;'#()<>+-/*=%$»« "
+lang_char: 'АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯЁабвгдежзийклмнопрстуфхцчшщъыьэюяёӘҒҚҢӨҰҮІҺәғқңөұүіһABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
+experiment_name: 'kz_synthtiger_v7'
+train_data: '../../synthtiger_kz/results/train_v7'
+valid_data: '../../synthtiger_kz/results/test_v7'
+manualSeed: 1111
+workers: 6
+batch_size: 96 #32
+num_iter: 100000
+valInterval: 1000
+saved_model: '' #'saved_models/en_filtered/iter_300000.pth'
+FT: False
+optim: False # default is Adadelta
+lr: 1.
+beta1: 0.9
+rho: 0.95
+eps: 0.00000001
+grad_clip: 5
+#Data processing
+select_data: 'images' # this is dataset folder in train_data
+batch_ratio: '1'
+total_data_usage_ratio: 1.0
+batch_max_length: 34
+imgH: 64
+imgW: 600
+rgb: False
+sensitive: True
+PAD: True
+contrast_adjust: 0.0
+data_filtering_off: False
+# Model Architecture
+Transformation: 'None'
+FeatureExtraction: 'VGG'
+SequenceModeling: 'BiLSTM'
+Prediction: 'CTC'
+num_fiducial: 20
+input_channel: 1
+output_channel: 256
+hidden_size: 256
+decode: 'greedy'
+new_prediction: False
+freeze_FeatureFxtraction: False
+freeze_SequenceModeling: False
+
+network_params:
+  input_channel: 1
+  output_channel: 256
+  hidden_size: 256
+lang_list:
+  - 'en'
+character_list: 0123456789!?.,:;'#()<>+-/*=%$»« АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯЁабвгдежзийклмнопрстуфхцчшщъыьэюяёӘҒҚҢӨҰҮІҺәғқңөұүіһABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

models/craft_mlt_25k.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4a5efbfb48b4081100544e75e1e2b57f8de3d84f213004b14b85fd4b3748db17
+size 83152330

requirements.txt

@@ -0,0 +1,108 @@
+altair~=5.1.2
+appnope~=0.1.3
+asttokens~=2.4.0
+attrs~=23.1.0
+backcall~=0.2.0
+backports.functools-lru-cache~=1.6.5
+blinker~=1.6.3
+Brotli~=1.1.0
+cachetools~=5.3.1
+certifi~=2023.7.22
+charset-normalizer~=3.3.0
+click~=8.1.7
+colorama~=0.4.6
+comm~=0.1.4
+debugpy~=1.8.0
+decorator~=5.1.1
+easyocr~=1.7.1
+exceptiongroup~=1.1.3
+executing~=1.2.0
+filelock~=3.12.4
+gitdb~=4.0.10
+GitPython~=3.1.37
+gmpy2~=2.1.2
+idna~=3.4
+imagecodecs~=2023.9.18
+imageio~=2.31.5
+importlib-metadata~=6.8.0
+importlib-resources~=6.1.0
+ipykernel~=6.25.2
+ipython~=8.16.1
+ipywidgets~=8.1.1
+jedi~=0.19.1
+Jinja2~=3.1.2
+jsonschema~=4.19.1
+jsonschema-specifications~=2023.7.1
+jupyter_client~=8.3.1
+jupyter_core~=5.3.2
+jupyterlab-widgets~=3.0.9
+lazy_loader~=0.3
+markdown-it-py~=3.0.0
+MarkupSafe~=2.1.3
+matplotlib-inline~=0.1.6
+mdurl~=0.1.0
+mpmath~=1.3.0
+nest-asyncio~=1.5.6
+networkx~=3.1
+numpy~=1.26.0
+opencv-python~=4.8.1
+packaging~=23.2
+pandas~=2.1.1
+parso~=0.8.3
+pexpect~=4.8.0
+pickleshare~=0.7.5
+Pillow~=10.0.1
+pip~=23.2.1
+pkgutil_resolve_name~=1.3.10
+platformdirs~=3.11.0
+prompt-toolkit~=3.0.39
+protobuf~=4.23.4
+psutil~=5.9.5
+ptyprocess~=0.7.0
+pure-eval~=0.2.2
+pyarrow~=13.0.0
+pyclipper~=1.3.0.post5
+pydeck~=0.8.0b4
+Pygments~=2.16.1
+PySocks~=1.7.1
+python-bidi~=0.4.2
+python-dateutil~=2.8.2
+pytz~=2023.3.post1
+PyWavelets~=1.4.1
+PyYAML~=6.0.1
+pyzmq~=25.1.1
+referencing~=0.30.2
+requests~=2.31.0
+rich~=13.6.0
+rpds-py~=0.10.4
+scikit-image~=0.22.0
+scipy~=1.11.3
+setuptools~=68.2.2
+shapely~=2.0.1
+six~=1.16.0
+smmap~=3.0.5
+stack-data~=0.6.2
+streamlit~=1.27.2
+sympy~=1.12
+tenacity~=8.2.3
+tifffile~=2023.9.26
+toml~=0.10.2
+toolz~=0.12.0
+torch~=2.0.0.post2
+torchvision~=0.15.2a0
+tornado~=6.3.3
+tqdm~=4.66.1
+traitlets~=5.11.2
+typing_extensions~=4.8.0
+tzdata~=2023.3
+tzlocal~=5.1
+urllib3~=2.0.6
+validators~=0.22.0
+watchdog~=3.0.0
+wcwidth~=0.2.8
+wheel~=0.41.2
+widgetsnbextension~=4.0.9
+zipp~=3.17.0
+pdf2image~=1.16.3
+pdfplumber
+PyMuPDF

upload_image.py

@@ -0,0 +1,25 @@
+import pandas as pd
+import numpy as np
+import streamlit as st
+import easyocr
+import PIL
+from PIL import Image, ImageDraw
+from matplotlib import pyplot as plt
+
+
+# main title
+st.set_page_config(layout="wide")
+st.title("Get text from image with EasyOCR") 
+# subtitle
+st.markdown("## EasyOCRR with Streamlit")
+col1, col2 = st.columns(2)
+uploaded_file = col1.file_uploader("Upload your file here ",type=['png','jpeg','jpg'])
+if uploaded_file is not None:
+    col1.image(uploaded_file) #display
+        #print("GOGO ",type(uploaded_file))
+    image = Image.open(uploaded_file)
+    reader = easyocr.Reader(['tr','en'], gpu=False) 
+    result = reader.readtext(np.array(image),paragraph=True)  # turn image to numpy array
+        #print(len(result))
+    result_text = "\n\n".join([item[1] for item in result])
+    col2.markdown(result_text)