Forem: FlyingBanana

Photes.io: An AI Assistant More Than Image-to-Text

FlyingBanana — Wed, 20 Nov 2024 10:26:00 +0000

When it comes to how to turn images to text, you must think of Photes.io. It is an AI tool using the most advanced OCR technology to recognize the information within the picture. However, Photes.io serves more than an image-to-text AI tool. It’s also a note-taking app and a platform to know more about others’ notes. Go ahead and explore more about Photes.io!

What’s OCR

Before introducing what Photes.io is, you must know something about OCR, the fundamental technology of Photes.io. Optical Character Recognition (OCR) is a technology that converts different types of documents, such as scanned paper documents, PDFs, or images captured by a digital camera, into editable and searchable data. Here are some key points about OCR:

Functionality: OCR software analyzes the shapes of letters and words in an image and translates them into machine-readable text. This process involves recognizing characters, words, and formatting to create a digital version of the original document.
Applications: OCR is widely used in various fields, including digitizing printed documents for archiving, automating data entry processes, enabling text-to-speech applications, and assisting in accessibility for visually impaired users.
OCR has evolved significantly with AI and machine learning, improving its ability to handle complex documents with different layouts, fonts, and languages. Its main features are as follows:
Image Quality: High-resolution images with clear contrast improve OCR accuracy.
Font Style and Size: OCR performs best with standard fonts. Handwritten text or highly stylized fonts can be challenging.
Language Support: Advanced OCR systems support multiple languages, which is crucial for international applications.

What’s Photes.io

Now you’ve mastered the fundamental technology of Photes.io. So what about Photes.io? What does it do and how to use it? Let me introduce more details.

Photes.io is an image-to-text tool converting complex infographics from images into editable and structured notes. Photes.io helps you grab the information in pictures and organize it to notes so that you could focus on more important things.

Key Features

AI-Powered Text Extraction: With the help of GPT-4, things Photes.io can do are beyond simple OCR. It can catch the key points accurately and output structured notes, even when your photos include complicated information like tables and charts.
Overall Recognition: One of the advantages of Photes.io is it could understand all kinds of information in your pictures, including text, chart like Venn or statistical graph.
Improved Structure: Instead of simple words recognition and output, Photes.io could recognize the image and output well-structured notes. It helps you keep your notes structured and easily available.
Wide Reference: More than extract information within your image, Photes.io will search related knowledge through the internet. So you can learn more beyond your image. Photes.io has its own strengths compared with its rivals. You can upload your photos and turn them into notes with just a few clicks. After you upload your photos, it’ll turn your photos to well-structured text notes with AI. More surprisingly, it can integrate with other note-taking apps you prefer.

How to Use Photes.io

Now you may be curious about how to use it. By the way, Photes.io support both laptop and phone. The first thing you should do is registering for an account.

To begin with, you’re equipped with 50 credits ever day. After signing up, you can upload you photos in your computer.

If you prefer use it on your phone, it’s also very convenient. Follow the steps below and you can get notes generated from your photos.

However, things Photes.io can do are more than turn your images to structured notes. Here are three more reasons attracting you to use it.

Photes.io serves as an AI Ency providing you more knowledge

When you upload your image to Photes.io, it’ll extract and summarize the information included in the image. Moreover, it’ll search more related knowledge through the internet and integrate all the information into a structured note for you.

Photes.io serves as a helper to manage your notes

Photes.io also serves as a note-taking app. You can not only use it as an image-to-text AI tool, but also use it as a helper to manage your notes. You can edit your notes and change the note books as you wish. Even you can integrate it with other note-taking apps like Notion, Obsidian, Google Docs.

Photes.io serves as a platform you explore others’ notes

Photes.io provides a platform that you can share your notes and explore other’s notes. There is no doubt that your note is private at first. If you want more credits or just want to share your note, you can make it public. In the Explore page, you can see many interesting notes shared by others.

Pricing

The app provides basic features for free, you can get a free trial. And you have daily limited credits. Though, you can get more credits by sharing your notes to public. Moreover, you could considerate the paid plans. Details are showed in the table below. The annual plan is more cost-effective! There’re also one-payment plans that $1 for one day, $2 for 3 days, and $3 for a week.

Click here to know more about the pricing!

Conclusion

Photes.io is a powerful AI tool that converts images into structured notes using advanced OCR. Beyond text extraction, it integrates with note-taking apps, enriches content with online references, and allows for easy sharing and management. Ideal for boosting productivity, it’s a versatile solution for efficiently handling visual information. Come have a try and enjoy you notes generated by Photes.io!

PyGWalker + Gradio = free Tableau

FlyingBanana — Mon, 23 Oct 2023 00:01:42 +0000

Interactive Data Visualization with PyGWalker & Gradio

pygwalker is a powerful tool for data scientists, akin to Tableau or PowerBI, to instantly transform data into interactive visuals within Jupyter Notebooks. But, the challenge arises in sharing these interactive experiences. Enter Gradio - a library that swiftly turns machine learning models and functions into web apps. This article provides a quick guide on pairing pygwalker with Gradio for enhanced data sharing.

Quick Introduction to Gradio

Gradio is more than just a Python library. It’s a bridge that connects your data or model with a user-friendly interface, making it simple to create and share web apps in just a few code lines.

Getting Started with PyGWalker in Gradio

Ensure you're running Python 3.6 or above. Then, you can commence with the following steps:

1. Set Up Your Environment

Ensure you've installed both pygwalker and gradio:

pip install pygwalker gradio

2. Code Preparations

Kick things off by importing the required libraries:

import gradio as gr
import pygwalker as pyg
from datasets import load_dataset

3. Data Loading

Here, we'll employ the NYC-Airbnb dataset from Gradio, though you're free to select your dataset:

dataset = load_dataset("gradio/NYC-Airbnb-Open-Data", split="train")
df = dataset.to_pandas()

4. Crafting the Gradio Interface

Using Gradio's Blocks feature, set up the UI components:

with gr.Blocks() as demo:
    gr.Label("Visualize NYC-Airbnb Data with PyGWalker & Gradio")
    gr.Markdown("Experience data interaction using pygwalker and gradio. Dive deep with drag-and-drop or commence your analysis!")
    gr.HTML(pyg.walk(dataset=df, spec="./viz-config.json", debug=False, return_html=True))

This segment configures the title, description, and integrates the pygwalker visualization into the Gradio UI.

5. Go Live!

Launch your web app with:

demo.launch()

Upon running, you'll witness the interactive visualization in a browser. Delve into the dataset using intuitive drag-and-drop or employ natural language (a kanaries API key activation is needed).

Wrapping Up

Merging pygwalker with gradio presents a streamlined avenue to craft and disseminate interactive data visualizations. This combo doesn't just amplify data probing but also broadens data insights' reach, granting even those without a tech background the ability to engage with your discoveries. Dive in and let the world see your insights!

Dive Deeper

Top 10 growing data visualization libraries in Python in 2023

FlyingBanana — Wed, 11 Oct 2023 02:55:08 +0000

Let's delve deeper into the new trending of the top 10 data visualization Python libraries in 2023. The ranking is based on the stars received by the library's github repo in 2023. The more stars it received, the higher it ranks.

No. 1 PyGWalker

Stars received by kanaries/pygwalker since 2023: 7486

The most popular data visualization python library in 2023. It turns your dataframe into an interactive data exploration app like tableau/powerBI with one line of code.

It provides simple drag-and-drop/chat interface for you to build charts.
It can run in juypter notebook, which means you do not need to switch between your code and the visualization app.
Besides, you can also build interactive spitial visualization on maps with it.

And it also has Javascript and R version.

Pros: Interactive data exploration app with one line of code; drag-and-drop/chat interface; interactive spitial visualization on maps.
Cons: Not very flexible to customizable styles;

Github: https://github.com/Kanaries/pygwalker
HomePage: PyGWalker Homepage

No. 2 Matplotlib

Stars received by matplotlib/matplotlib since 2023: 1821

Matplotlib is a very traditional data visualization library in Python published in 2003. It is the foundation of many other libraries, such as seaborn, pygal, and so on.
It is very flexible and customizable, but it is also very verbose and not very efficient, which usually requires extensive code for simple visualizations.

Pros: Foundation for many other libraries; highly customizable.
Cons: Steeper learning curve; can require extensive code for simple visualizations; aesthetics might seem outdated.

Github: https://github.com/matplotlib/matplotlib

No. 3 Plotly

Stars received by plotly/plotly.py since 2023: 1705

Plotly is also a multi-platform data visualization library like pygwalker. Plotly's company also builds Dash, which can turn your plotly charts code into a web app like a dashboard.

Pros: Delivers interactive, web-ready visualizations; can be published as data apps with dash.
Cons: Online mode requires an internet connection; the free version has limitations on the number of plots and public visibility.

Github: https://github.com/plotly/plotly.py

No. 4 Bokeh

Stars received by bokeh/bokeh since 2023: 1126

Bokeh is created by Anaconda, which is a very famous company in data science world.

Pros: Built for interactive web visualizations; handles large datasets efficiently.
Cons: Syntax may seem unfamiliar to Matplotlib users; more tailored to web applications than static plots.

Github: https://github.com/bokeh/bokeh

No. 5 Seaborn

Stars received by mwaskom/seaborn since 2023: 1111

Seaborn is is build based on matplotlib, which means it benefits from the flexibility of matplotlib, but also inherits the verbosity of matplotlib.

Pros: Built on Matplotlib with enhanced aesthetics; efficient for statistical plots.
Cons: Less customizable than Matplotlib; might not be suitable for advanced or non-statistical plots.

Github: https://github.com/mwaskom/seaborn

No. 6 pyecharts

Stars received by pyecharts/pyecharts since 2023: 1015

pyecharts is the python binding of the famous data visualization library apache/echarts in Javascript.

Pros: support a wide range of chart types, even 3D and webGL.
Cons: complex options config.

Github: https://github.com/pyecharts/pyecharts

No. 7 Altair

Stars received by altair-viz/altair since 2023: 604

Altair is build based on vega-lite, which is a very famaous data visualization library in Javascript and the academic world of visualization. It benefits almost all the advantages of vega-lite, such as declarative approach, web-ready outputs, and so on.
The most important advatage is its declarative specification of interaction, which according to vega-lite's paper, as the grammar of interactive graphics.

Pros: Declarative approach simplifies code; generates web-ready outputs. More intuitive operators for making graphics.
Cons: Due to vega-lite, there is a limit of customization/chart types. Making complex charts might require user to design complex signal flows.

Github: Altair

No. 8 plotnine

Stars received by has2k1/plotnine since 2023: 323

plotnine is designed based on the grammar of graphics, which is a very famous theory in the academic world of visualization. The theory is also the foundation of ggplot2 in R.

Github: https://github.com/has2k1/plotnine

No. 9 Holoviews

Stars received by holoviz/holoviews since 2023: 169

Holoviews is build based on bokeh, which means it benefits from the efficiency of bokeh, but also inherits the unfamiliar syntax of bokeh.

Github: https://github.com/holoviz/holoviews

No. 10 vispy

Stars received by vispy/vispy since 2023: 154

vispy is targeted at users who are interested in OpenGL. It provides some low-level APIs for users to build more flexible and customizable graphics.

Github: https://github.com/vispy/vispy

Conclusion

In 2023, Python's data visualization landscape is rich and varied, with PyGWalker leading the charge towards intuitive, interactive exploration tools. While traditional powerhouses like Matplotlib remain relevant, there's a notable shift towards web-ready and interactive visualizations, as seen with Plotly and Bokeh. The diversity in this top 10 list indicates that the ideal library hinges on project specifics and personal preference.

Key Takeaways:

PyGWalker's rise signifies the demand for user-friendly, interactive data tools.
Web-ready visualizations are gaining traction.
Traditional libraries like Matplotlib still hold importance due to their flexibility.
The right choice depends on project needs and desired customization.

Unlocking Interactive Visualizations in Jupyter Notebook: PyGWalker Meets Snowflake

FlyingBanana — Tue, 10 Oct 2023 04:27:53 +0000

In the evolving world of data analysis, interactivity and user experience play a pivotal role. Analysts need solutions that are both powerful in handling large datasets and flexible in presenting insights. PyGWalker is an intriguing solution that offers the ability to turn your Pandas dataframes into interactive visualizations right within your Jupyter notebooks. Essentially, it serves as an open-source alternative to heavyweight visualization platforms like Tableau and PowerBI.

In this article, we'll explore how you can supercharge PyGWalker by integrating it with Snowflake, a cloud data platform known for its capability to process enormous datasets efficiently.

Getting Started

Installation

To kick things off, you need to install the pygwalker library and the accompanying Snowflake plugin. Use the pip commands below:

pip install --upgrade --pre pygwalker
pip install --upgrade --pre "pygwalker[snowflake]"

Setting Up The Connector

The primary step in integrating PyGWalker with Snowflake is setting up a connector. This allows the library to fetch data directly from Snowflake databases and turn it into interactive plots.

Here's a quick code snippet to guide you:

import pygwalker as pyg
from pygwalker.data_parsers.database_parser import Connector

conn = Connector(
    "snowflake://user_name:password@account_identifier/database/schema",
    """
        SELECT
            *
        FROM
            SNOWFLAKE_SAMPLE_DATA.TPCH_SF1.ORDERS
    """
)

walker = pyg.walk(conn)

Note: Ensure that you replace the placeholders in the connection string with your Snowflake credentials.

Understanding The Connection String

Snowflake provides two formats for the connection string:

Account Name Format:

   snowflake://<user_login_name>:<password>@<orgname>-<account_name>

Account Locator Format:

   snowflake://<user_login_name>:<password>@<account_locator>.<region_id>.<cloud>

Choose the format that best suits your Snowflake setup.

Wrapping Up

With PyGWalker's integration with Snowflake, analysts can now effortlessly visualize vast datasets right within their Jupyter notebooks. This synergy transforms data analysis workflows, offering both depth and ease. So the next time you're looking for a nimble yet powerful data visualization solution, consider giving PyGWalker and Snowflake a whirl!

Related resources

pygwalker + snowflake official doc

PyGWalker with DuckDB is all you need for large data exploration

FlyingBanana — Tue, 15 Aug 2023 10:43:32 +0000

PyGWalker is a python library that turns your pandas dataframe into a tableau style user interface for visual analysis.

It is very convenient for data analysts to explore and visualize their dataset. For any dataframe in python, you can turn it into a visual exploration interface with only one line of code:

import pandas as pd
import pygwalker as pyg

df = pd.read_csv('your_dataset.csv')

# start explore your dataset!
walker = pyg.walk(df)

which then you can start your analysis.

In the past, visual exploration costs time and numbers of code to implement. But with pygwalker, you do not need to google how to make visualizations, just use drag and drop operations or natural language queries to visualize your data.

In early versions of PyGWalker, there still some performance issues for handling large dataset.

However, a recent update (version 0.4.2) of pygwalker published with a new computation engine based on DuckDB. It boost its performance and allow you to explore much larger datasets.

Another test with 300M rows only cost 500ms for user's operation. Maybe in most of cases, you don't need a heavy BI systems with large computation cluster services.

A PyGWalker with DuckDB on your local devices is all you need.

PyGWalker: A Python Library for Exploratory Data Analysis with Visualization

FlyingBanana — Mon, 06 Mar 2023 11:52:07 +0000

PyGWalker: A Python Library for Exploratory Data Analysis with Visualization

PyGWalker can simplify your Jupyter Notebook data analysis and data visualization workflow, by turning your pandas dataframe (and polars dataframe) into a Tableau-style User Interface for visual exploration.

PyGWalker (pronounced like "Pig Walker", just for fun) is named as an abbreviation of "Python binding of Graphic Walker". It integrates Jupyter Notebook (or other jupyter-based notebooks) with Graphic Walker, a different type of open-source alternative to Tableau. It allows data scientists to analyze data and visualize patterns with simple drag-and-drop operations.

Visit Google Colab, Kaggle Code, Binder or Graphic Walker Online Demo to test it out!

PyGWalker will add more support such as R in the future.

Getting Started

Tested Environments

[x] Jupyter Notebook
[x] Google Colab
[x] Kaggle Code
[x] Jupyter Lab (WIP: There're still some tiny CSS issues)
[x] Databricks Notebook (Since version 0.1.4)
[x] Jupyter Extension for Visual Studio Code (Since version 0.1.4)
[x] Hex Projects (Since version 0.1.4)
[x] Most web applications compatiable with IPython kernels. (Since version 0.1.4)
[ ] ...feel free to raise an issue for more environments.

Run in Kaggle	Run in Colab

Setup pygwalker

Before using pygwalker, make sure to install the packages through the command line using pip or conda.

pip

pip install pygwalker

Note

For an early trial, you can install with pip install pygwalker --upgrade to keep your version up to date with the latest release or even pip install git+https://github.com/Kanaries/pygwalker@main to obtain latest features and bug-fixes.

Conda-forge

conda install -c conda-forge pygwalker

mamba install -c conda-forge pygwalker

See conda-forge feedstock for more help.

Use pygwalker in Jupyter Notebook

Import pygwalker and pandas to your Jupyter Notebook to get started.

import pandas as pd
import pygwalker as pyg

You can use pygwalker without breaking your existing workflow. For example, you can call up Graphic Walker with the dataframe loaded in this way:

df = pd.read_csv('./bike_sharing_dc.csv', parse_dates=['date'])
gwalker = pyg.walk(df)

And you can use pygwalker with polars (since pygwalker>=0.1.4.7a0):

import polars as pl
df = pl.read_csv('./bike_sharing_dc.csv',try_parse_dates = True)
gwalker = pyg.walk(df)

You can even try it online, simply visiting Binder, Google Colab or Kaggle Code.

That's it. Now you have a Tableau-like user interface to analyze and visualize data by dragging and dropping variables.

Cool things you can do with Graphic Walker:

You can change the mark type into others to make different charts, for example, a line chart:

To compare different measures, you can create a concat view by adding more than one measure into rows/columns.

To make a facet view of several subviews divided by the value in dimension, put dimensions into rows or columns to make a facets view. The rules are similar to Tableau.
You can view the data frame in a table and configure the analytic types and semantic types.
You can save the data exploration result to a local file

For more detailed instructions, visit the Graphic Walker GitHub page.

Resources

Check out more resources about Graphic Walker on Graphic Walker GitHub
We are also working on RATH: an Open Source, Automate exploratory data analysis software that redefines the workflow of data wrangling, exploration and visualization with AI-powered automation. Check out the Kanaries website and RATH GitHub for more!
If you encounter any issues and need support, join our Slack or Discord channels.

Have a Bad memory? Open Source N-Back game may help improve your working memory

FlyingBanana — Tue, 07 Feb 2023 15:58:38 +0000

Open Recall

Open Recall is an Open Source N-Back Task Game like Simply-Recall designed to improve working memory and cognitive abilities.

Research shows that N-Back training may lead to gains in fluid intelligence (IQ) and working memory ability (Soveri et al., 2017).

The N-Back task is a memory training game that is designed to improve working memory and cognitive abilities. To play the game, you will be presented with a sequence of items such as letters, numbers, or words. Your goal is to indicate whenever the current item matches the item that was presented "n" steps back in the sequence. The value of "n" determines the difficulty of the task. For example, if "n" is set to 1, you would need to recall the item that was presented one step back. If "n" is set to 2, you would need to recall the item that was presented two steps back, and so on. The game typically continues until you have completed a certain number of rounds or made a certain number of errors. To play, simply focus on the items as they are presented and try to recall the item that was presented "n" steps back. Good luck!

Play it

You can play the game at Open Recall On Vercel

Github Repo at Open Recall

Game

step 1: click start button.
step 2: set game time limit and level, and click play button.
step 3: enjoy the game.

Home	Setting	Guide

Playing	Score	History

When Level = 2, you need to remember the previous two items. Suppose we have a list: Apple (n - 2), Banana (n - 1), Apple (n). Click yes because the current item is the same as the item two steps back.

Deploy

npm install
npm run build

Graphic-Walker: A different type of open-source alternative to Tableau

FlyingBanana — Fri, 03 Feb 2023 12:18:14 +0000

Hello, guys~ Recently, I have been participating in development of a data exploration and visualization app which can be used as a different type of open-source alternative to Tableau. It is extremely easy to embed in your apps just as a react component. The original purpose is to develop a lite plugin that can be easily embedded in most cases, it doesn't have to be a large heavy BI system, but a lite graphic plugin.

GitHub: Kanaries/graphic-walker, https://github.com/Kanaries/graphic-walker

The main features implemented:

A user-friendly drag-and-drop-based interaction for exploratory data analysis with visualizations.
A grammar of graphics-based visual analytic user interface where users can build visualization from low-level visual channel encodings.
A Data Explainer explains why some patterns occur / what may cause them.
Using web workers and indexed DB to handle computation tasks which allows you to use it as a pure front-end app. (working on use duckDB as data engine.)

And you can use it in your app as a react component!

import { GraphicWalker } from '@kanaries/graphic-walker';

const YourEmbeddingTableauStyleApp: React.FC = props => {
    const { dataSource, fields } = props;
    return <GraphicWalker
        dataSource={dataSource}
        rawFields={fields}
        spec={graphicWalkerSpec}
        i18nLang={langStore.lang}
    />
}

export default YourEmbeddingTableauStyleApp;

Feedbacks and advice are welcome! What features do you think are important to add?

Using Pivot Chart to Replace Your Pivot Table

FlyingBanana — Sun, 29 Jan 2023 16:52:54 +0000

Pivot-Chart is an open-source comprehensive data visualization tool that enhances pivot tables with visualizations and charts, offering a more intuitive and informative way to analyze your data. With Pivot-Chart, you can elevate your data analysis and take a new approach to exploring your data. Unlike other pivot-table + vis solution, pivot chart retains nest multi-level aggregation feature of pivot table, which allows you to compare between different aggregation levels and make it easier to drill down and roll up.

Integrating Pivot-Chart into your data applications is easy, simply import the npm package. While this is a proof-of-concept project, your feedback and suggestions are valued and appreciated.

features:

All pivot table features
Supports cell display as charts
Retains nest multi-level aggregation feature of pivot table
Easy to use and integrate with your projects as a component in web.
Open-source and customizable to meet your needs

Github Repo: https://github.com/ObservedObserver/pivot-chart
Demo on Vercel: https://pivot-chart.vercel.app/
HN: https://news.ycombinator.com/item?id=34569184

Forem: FlyingBanana

Photes.io: An AI Assistant More Than Image-to-Text

What’s OCR

What’s Photes.io

Key Features

How to Use Photes.io

Photes.io serves as an AI Ency providing you more knowledge

Photes.io serves as a helper to manage your notes

Photes.io serves as a platform you explore others’ notes

Pricing

Conclusion

PyGWalker + Gradio = free Tableau

Interactive Data Visualization with PyGWalker & Gradio

Quick Introduction to Gradio

Getting Started with PyGWalker in Gradio

1. Set Up Your Environment

2. Code Preparations

3. Data Loading

4. Crafting the Gradio Interface

5. Go Live!

Wrapping Up

Dive Deeper

Top 10 growing data visualization libraries in Python in 2023

No. 1 PyGWalker

No. 2 Matplotlib

No. 3 Plotly

No. 4 Bokeh

No. 5 Seaborn

No. 6 pyecharts

No. 7 Altair

No. 8 plotnine

No. 9 Holoviews

No. 10 vispy

Conclusion

Key Takeaways:

Unlocking Interactive Visualizations in Jupyter Notebook: PyGWalker Meets Snowflake

Getting Started

Installation

Setting Up The Connector

Understanding The Connection String

Wrapping Up

Related resources

PyGWalker with DuckDB is all you need for large data exploration

PyGWalker: A Python Library for Exploratory Data Analysis with Visualization

PyGWalker: A Python Library for Exploratory Data Analysis with Visualization

Getting Started

Tested Environments

Setup pygwalker

pip

Conda-forge

Use pygwalker in Jupyter Notebook

Resources

Have a Bad memory? Open Source N-Back game may help improve your working memory

Open Recall

Play it

Game

Deploy

Graphic-Walker: A different type of open-source alternative to Tableau

Using Pivot Chart to Replace Your Pivot Table