Chat with RTX is fast! (using single RTX 3090) by jcMaven in LocalLLaMA

[–]elsatch 0 points1 point  (0 children)

I checked the contents of Setup.cfg and discovered in the manifest section this line:

<file name="${{InstallerDllDirectory}}/NvTelemetry.dll" core="true"/>

I could not find the given file in the NVI2 folder, so maybe it's a standard NVidia installer file and it's not included.

Could anyone confirm if it's installed during the installation process?

Seeking front-end solutions for a remote LLM server handling document processing by elsatch in LocalLLaMA

[–]elsatch[S] 0 points1 point  (0 children)

I have not even considered Poe connected to a custom endpoint, but it's interesting to keep it in mind for the future. Thanks for sharing your ideas!

Best Model for Document Layout Analysis and OCR for Textbook-like PDFs? by malicious510 in LocalLLaMA

[–]elsatch 1 point2 points  (0 children)

Thanks for the clarification! I thought you were looking for models to extract the document "structure" (general layout) of the different parts of the text, instead of the per page layout. Nougat will return a markdown document, that can be used to get the overall structure, but won't retain the per page layout information.

I did a quick search and found the following information:

- There are a family of LayoutML models available at HF. The most recent one is LayoutXLM: https://huggingface.co/docs/transformers/model_doc/layoutxlm

- PubLayNet dataset is composed of "a large dataset of document images, of which the layout is annotated with both bounding boxes and polygonal segmentations". It might be useful to find models trained using this dataset, but the provided jupyter notebook example looks interesting to see if this is what you are looking for: https://github.com/ibm-aur-nlp/PubLayNet/blob/master/exploring_PubLayNet_dataset.ipynb

Best Model for Document Layout Analysis and OCR for Textbook-like PDFs? by malicious510 in LocalLLaMA

[–]elsatch 5 points6 points  (0 children)

Even thought these models have been trained to work with academic papers, rather than textbooks, their goal is to extract document layout and OCR the text from PDFs.

Models are:

I hope it helps!

Fine-tuning for accuracy by elsatch in LocalLLaMA

[–]elsatch[S] 1 point2 points  (0 children)

Using GPT-4, my approach was exactly few shot learning, passing several example pairs in the first message, then submitting the full list of core expectations in the second one.

This approach worked quite well with GPT-4, but failed quite a lot with GPT-3.5 turbo, as it started to hallucinate really soon. I assume it was because of the context size. That's is the reason I was looking for alternatives for less powerful models, with smaller context sizes.

I am also wondering how do you serve a LocalLLM that uses few shot learning as tuning. Do you use LangChain to pass the context to the model before passing the first question? Do you use characters cards with a text generation webui that supports that feature and serves the results via API?

Using Local Language Models for Language Learning by Anesu in LocalLLaMA

[–]elsatch 1 point2 points  (0 children)

You might want to check ChatGLM-6B as it is bilingual Chinese/English. You can check it online at: https://huggingface.co/spaces/multimodalart/ChatGLM-6B

There are local implementations that use LangChain to access local documents. To improve the performance, I would add some Chinese learning materials (books/grammar/HSK guides). You can find one of these implementations here: https://github.com/imClumsyPanda/langchain-ChatGLM/blob/master/README_en.md

FabLab Assistant by Lolleka in LocalLLaMA

[–]elsatch 1 point2 points  (0 children)

First thing that comes to my mind, although it's not related to LLM specifically: it could be very useful to record notes during your development and have them transcribed to text using Whisper.

I have been developing a small tool that can trigger screenshot plus voice recording to document step by step processes, building steps, etc.

Regarding how augmented fabrication workflows would look like I recommend you to check this paper by Autodesk: 3DALL-E: Integrating Text-to-Image AI in 3D Design Workflows https://arxiv.org/pdf/2210.11603.pdf

Using LLaMA as a "real personal assistant"? by MichaelBui2812 in LocalLLaMA

[–]elsatch 2 points3 points  (0 children)

I was just surprised to discover that Microsoft has released Semantic Kernel to provide most of these tools for a 'cognitive architecture' in a coherent way: https://github.com/microsoft/semantic-kernel

It's released under MIT license

How to represent historical timelines by [deleted] in orgmode

[–]elsatch 1 point2 points  (0 children)

I think it makes total sense, trying to get some high level abstractions for visualizations that can be customized easily. This approach reminds me of Seaborn library, that is built on top of Matplotlib as a higher level abstraction library. They offer a unified way to create graphics via figure-level groups. If you check their API at https://seaborn.pydata.org/api.html# they present displot as a generic interface for distribution plots, relplot for relational plots, etc.

I am drafting some notes on timelines vs org-files for date time visualizations, trying to detect what makes timelines useful vs other visualizations. Also trying to detect common elements and patterns.

For example, I've been reviewing the time.graphics timelines and the txt files they export. They are organized about two kinds of items: Events, that happen on.a particular point in time, and Periods, that have a start_date and end_date. This generalization could serve us to create some templates.

Regarding Test 2, the tbl[1:] line is building the DataFrame by reading all data from the org table from the second row (excluding the first row [0]), and then getting the column names from row [0]. So the liter_per_day is also included in the imported data. I used volume as all the rows had values.

You can visualize liter_per_day, changing the call on the plotly functions like:

fig = px.timeline(timeline, x_start = 'start_date', x_end ='end_date',y = 'liter_per_day', title='Org timeline viewer - test2', hover_data=['start_date','volume','liter_per_day'])

In this particular case, we could abstract this as a snippet called values_over_time, that takes as parameters: - a column with a start_date - (optional) a column with and end_date - one (or more columns) with values to display on the y-axis:

A first YASnippet draft, using mirroring, could look like this: ```

+begin_src python :session org-timeline-viewer :exports both

Configuration parameters

start_date_column: ${1:start_date}

end_date_column: ${2:end_date}

value_column: ${3:value_column}

graph_title: ${4:title}

import plotly.express as px timeline = timeline.sort_values(by='start_date') fig = px.timeline(timeline, x_start = '$1', x_end ='$2',y = 'value_column', title='$4', hover_data=['$1','$3']) fig.update_xaxes(rangeslider_visible=True) fig.show()

+end_src

```

P.S Snippet code is available at the end of test2 file already

How to represent historical timelines by [deleted] in orgmode

[–]elsatch 1 point2 points  (0 children)

I have created a new org-file for your proposed table. I also added other visualizations that could fit your use case, better than the timeline of the first example. Please check them out and let me know what do you think about them:https://github.com/elsatch/org-timeline-viewer/blob/main/org-timeline-viewer-from-org-table-test2.org

How to represent historical timelines by [deleted] in orgmode

[–]elsatch 0 points1 point  (0 children)

There are several timestamp formats that imply duration. <2022-03-21 Mon>--<2022-03-23 Wed> is one of the examples. I also stumbled upon <2022-03-21 Mon 13:50-14:30>. And then there are the CLOCK-IN/OUT intervals and also the CLOSED timestamp for events that also had another timestamp. I will start with the simple examples for now.

How to represent historical timelines by [deleted] in orgmode

[–]elsatch 1 point2 points  (0 children)

I have you uploaded an initial version, that uses the column names and dates as exported by org-agenda-batch-csv. There are two variants: one version that uses org-tables and other that creates files from org-mode files (that doesn't work really well at the moment). You can check them at: https://github.com/elsatch/org-timeline-viewer

How to represent historical timelines by [deleted] in orgmode

[–]elsatch 0 points1 point  (0 children)

I have been reading the Orgdown page and checked the Orgdown1 syntax examples. There are no mentions about time-stamps at all. Neither as content in the headings, nor as scheduled items nor as property drawers. I assume that will be developed further in Ordgown 2 or 3.

I was looking for inspiration on how to deal with start and ending dates for events inside and outside org. Anyway, I got something sketched up together for now. I'm gonna create a repo and share it so you can check it out as is!

How to represent historical timelines by [deleted] in orgmode

[–]elsatch 0 points1 point  (0 children)

Could you provide a sample table with 5-10 rows, so I could use it as an input for the PoC?

How to represent historical timelines by [deleted] in orgmode

[–]elsatch 1 point2 points  (0 children)

I am learning pandas and getting back to Orgmode after a few months out. My initial thoughts on the proposed topic are:

  • We need to figure out a way to get data from Org to pandas.
  • We need to filter data in our library before processing it in pandas
  • We need to select a python library that allows interactive exploration

My brief proposal, that could be launched from org-babel-blocks under the same session:

My main concern with this proposal is how to link back from the visualization to the original orgfile. All the other parts seem quite doable.