category
stringclasses 107
values | title
stringlengths 15
179
| question_link
stringlengths 59
147
| question_body
stringlengths 53
33.8k
| answer_html
stringlengths 0
28.8k
| __index_level_0__
int64 0
1.58k
|
|---|---|---|---|---|---|
implement RAG
|
Connection error when using langchain_community.vectorstores.faiss.FAISS
|
https://stackoverflow.com/questions/78147781/connection-error-when-using-langchain-community-vectorstores-faiss-faiss
|
<p>I found a methodology to use RAG (retrieval-augmented generation) with a Large Language Model (LLM) to answer question about a provided transcriptions. Here is the GitHub link: <a href="https://github.com/ingridstevens/whisper-audio-transcriber" rel="nofollow noreferrer">https://github.com/ingridstevens/whisper-audio-transcriber</a></p>
<p>I tried to implement it for my use case but I ran into trouble when it comes connecting to the Meta API FAISS embedded by the Langchain module.</p>
<p>Here is my code (I'm working on Google Colab):</p>
<pre><code>from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.vectorstores import FAISS
from langchain.embeddings import OllamaEmbeddings
from langchain.chains.qa_with_sources import load_qa_with_sources_chain
from langchain.chains import LLMChain
from langchain.llms import Ollama
audio = "./gdrive/MyDrive/test_long.m4a"
segments, info = model.transcribe(
audio,
beam_size=8,
vad_filter=True,
vad_parameters=dict(min_silence_duration_ms=100),
)
print("Detected language '%s' with probability %f" % (info.language, info.language_probability))
text = []
for segment in segments:
text.append(segment.text)
print("[%.2fs -> %.2fs] %s" % (segment.start, segment.end, segment.text))
transcription = ''
for sentence in text:
transcription += sentence
splitter = RecursiveCharacterTextSplitter(
chunk_size=500,
chunk_overlap=50,
)
texts = splitter.split_text(transcription)
# Define the embeddings
embeddings = OllamaEmbeddings()
# Create the vector store using the texts and embeddings and put it in a vector database
docsearch = FAISS.from_texts(texts, embeddings, metadatas=[{"file": audio,"source": str(i)} for i in range(len(texts))])
</code></pre>
<p>And here is the error occurring:</p>
<pre><code>---------------------------------------------------------------------------
ConnectionRefusedError Traceback (most recent call last)
/usr/local/lib/python3.10/dist-packages/urllib3/connection.py in _new_conn(self)
202 try:
--> 203 sock = connection.create_connection(
204 (self._dns_host, self.port),
24 frames
ConnectionRefusedError: [Errno 111] Connection refused
The above exception was the direct cause of the following exception:
NewConnectionError Traceback (most recent call last)
NewConnectionError: <urllib3.connection.HTTPConnection object at 0x7b9d21e23970>: Failed to establish a new connection: [Errno 111] Connection refused
The above exception was the direct cause of the following exception:
MaxRetryError Traceback (most recent call last)
MaxRetryError: HTTPConnectionPool(host='localhost', port=11434): Max retries exceeded with url: /api/embeddings (Caused by NewConnectionError('<urllib3.connection.HTTPConnection object at 0x7b9d21e23970>: Failed to establish a new connection: [Errno 111] Connection refused'))
During handling of the above exception, another exception occurred:
ConnectionError Traceback (most recent call last)
ConnectionError: HTTPConnectionPool(host='localhost', port=11434): Max retries exceeded with url: /api/embeddings (Caused by NewConnectionError('<urllib3.connection.HTTPConnection object at 0x7b9d21e23970>: Failed to establish a new connection: [Errno 111] Connection refused'))
During handling of the above exception, another exception occurred:
ValueError Traceback (most recent call last)
/usr/local/lib/python3.10/dist-packages/langchain_community/embeddings/ollama.py in _process_emb_response(self, input)
161 )
162 except requests.exceptions.RequestException as e:
--> 163 raise ValueError(f"Error raised by inference endpoint: {e}")
164
165 if res.status_code != 200:
ValueError: Error raised by inference endpoint: HTTPConnectionPool(host='localhost', port=11434): Max retries exceeded with url: /api/embeddings (Caused by NewConnectionError('<urllib3.connection.HTTPConnection object at 0x7b9d21e23970>: Failed to establish a new connection: [Errno 111] Connection refused'))
</code></pre>
<p>I also have tried without the "metadatas" parameter but nothing changed:</p>
<pre><code>docsearch = FAISS.from_texts(texts, embeddings)
</code></pre>
<p>Does someone know where the issue comes from and how to fix it?</p>
| 1,434
|
|
implement RAG
|
How can I implement Auto-merging Retriever (aka Parent Document Retriever) directly with Pinecone (or other VectorDB)?
|
https://stackoverflow.com/questions/77719901/how-can-i-implement-auto-merging-retriever-aka-parent-document-retriever-direc
|
<p>Context: I'm trying to implement an advanced RAG pipeline that uses <a href="https://docs.llamaindex.ai/en/latest/examples/retrievers/auto_merging_retriever.html" rel="nofollow noreferrer">Auto-merging Retriever</a> (aka <a href="https://python.langchain.com/docs/modules/data_connection/retrievers/parent_document_retriever" rel="nofollow noreferrer">Parent Document Retriever</a>) against specific VectorDB (for example, Pinecone).</p>
<p>It looks like all of LlamaIndex / LangChain <a href="https://docs.llamaindex.ai/en/stable/examples/retrievers/recursive_retriever_nodes.html" rel="nofollow noreferrer">tutorials</a> assume the end users uses a generic "index" that can represent any VectorDB but it's not super clear to me how I can leverage their code sample to use specific VectorDB.</p>
<p>In particular, how can I save <a href="https://docs.llamaindex.ai/en/stable/examples/retrievers/recursive_retriever_nodes.html#metadata-references-summaries-generated-questions-referring-to-a-bigger-chunk" rel="nofollow noreferrer">https://docs.llamaindex.ai/en/stable/examples/retrievers/recursive_retriever_nodes.html#metadata-references-summaries-generated-questions-referring-to-a-bigger-chunk</a>:</p>
<pre><code>from llama_index import VectorStoreIndex
...
vector_index_chunk = VectorStoreIndex(
all_nodes, service_context=service_context
)
...
from llama_index.retrievers import RecursiveRetriever
...
retriever_metadata = RecursiveRetriever(
"vector",
retriever_dict={"vector": vector_retriever_metadata},
node_dict=all_nodes_dict,
verbose=True,
)
</code></pre>
<p>in VectorDB (for example, Pinecone).</p>
<p>While I can see how I could sub optimally save VectorStoreIndex to Pinecone by writing a lot of metadata (even though I suspect there's a convenient library method for it), I don't understand at all, how I could leverage these RecursiveRetriever objects with Pinecone client libraries (especially given that my microservice isn't written in Python.</p>
<p>I tried to search on GitHub but didn't manage to find anything relevant which was very surprising to me.</p>
| 1,435
|
|
implement RAG
|
Returning document sources using LCEL
|
https://stackoverflow.com/questions/78072019/returning-document-sources-using-lcel
|
<p>I am implementing the example provided here: <a href="https://python.langchain.com/docs/templates/neo4j-advanced-rag" rel="nofollow noreferrer">https://python.langchain.com/docs/templates/neo4j-advanced-rag</a></p>
<p>However, I'd like to enhance the functionality to return the sources (aka context) that was supplied to the model. I tried to go through the documentation provided here: <a href="https://python.langchain.com/docs/use_cases/question_answering/sources#adding-sources" rel="nofollow noreferrer">https://python.langchain.com/docs/use_cases/question_answering/sources#adding-sources</a>, but couldn't understand how to apply that in the code below:</p>
<pre><code>prompt = ChatPromptTemplate.from_messages(
[
("system", "You are an AI chatbot having a conversation with a human."),
MessagesPlaceholder(variable_name="history"),
("human", "Given this history: {history} and \n this context:\n{context}\n, answer the questions below\nQuestion:{question}. \
by strictly following this instruction: Answer the question based only on the context and nothing else. If you cannot answer, simply say - I don't know. "),
]
)
model = AzureChatOpenAI(openai_api_type='azure',
deployment_name=azure_chat_deploy_name,
openai_api_version=azure_api_version,
openai_api_key=azure_api_key,
azure_endpoint=azure_base)
retriever = typical_rag.as_retriever().configurable_alternatives(
ConfigurableField(id="strategy"),
default_key="typical_rag",
parent_strategy=parent_vectorstore.as_retriever(),
hypothetical_questions=hypothetic_question_vectorstore.as_retriever(),
summary_strategy=summary_vectorstore.as_retriever(),
)
chain = (
RunnableParallel(
{
"context": itemgetter("question") | retriever ,
"question": itemgetter("question"),
"history": itemgetter("history")
}
)
| prompt
| model
| StrOutputParser()
)
# Add typing for input
class Question(BaseModel):
question: str
chain = chain.with_types(input_type=Question, output_type=Context)
chain_with_history = RunnableWithMessageHistory(
chain,
lambda session_id: msgs,
input_messages_key="question",
history_messages_key="history"
)
print(chain_with_history.astream_events)
# Render current messages from StreamlitChatMessageHistory
for msg in msgs.messages:
st.chat_message(msg.type).write(msg.content)
if user_question := st.chat_input():
st.chat_message("human").write(user_question)
config = {"configurable": {"session_id": "any"}}
response = chain_with_history.invoke({"question": user_question}, config)
print("Response:",response)
st.chat_message("ai").write(response)
</code></pre>
<p>Any help/pointers is greatly appreciated?
Thanks</p>
|
<p>Not sure why my question received negative vote, but for anyone looking for this, posting the answer:
Modified the code as below to add the context as well to the chain</p>
<pre><code>chain = ( {
"context": itemgetter("question") | retriever ,
"question": itemgetter("question"),
"history": itemgetter("history")
} | RunnableParallel ({
"response": prompt | model,
"context": itemgetter("context") # This adds the retrieved context as well to the chain
})
)
</code></pre>
<p>and then the context can be retrieved from model response as below:</p>
<pre><code>model_output = chain_with_history.invoke({"question": user_question}, config)
response = model_output['response'].content
provided_context = ' '.join(document.page_content for document in model_output['context'])
print(f"Context sent to the model: {provided_context}")
</code></pre>
| 1,436
|
implement RAG
|
How to Implement Chat-Specific Vector Embeddings and Manage Token Limits in a Serverless Chat Application Using Azure?
|
https://stackoverflow.com/questions/78917444/how-to-implement-chat-specific-vector-embeddings-and-manage-token-limits-in-a-se
|
<p><strong>Question:</strong></p>
<p>I'm developing a chat application similar to ChatGPT using Azure's serverless model. The application includes several functionalities such as document upload, vector embeddings storage, and AI-powered responses. However, I'm facing multiple challenges and would appreciate any guidance or best practices.</p>
<p><strong>Key Points:</strong></p>
<ol>
<li><p><strong>Chat-Specific Vector Embeddings:</strong><br />
I want to store vector embeddings that are specific to a particular chat session. For example, when a user uploads a document to a particular chat, the files and their vector embeddings should be restricted to that chat only. I'm using Azure services for this purpose. What is the best way to implement this architecture? Should I store the embeddings in Azure Cognitive Search, or is there a better approach for chat-specific storage?</p>
</li>
<li><p><strong>Handling Token Limits in RAG (Retrieval-Augmented Generation) Applications:</strong><br />
My application involves a RAG setup where users might upload multiple documents (e.g., resumes), and I need to retrieve information about all candidates simultaneously. However, when passing all the retrieved information from Azure AI Search to the OpenAI API, I encounter token limit issues, leading to 429 errors. I’m using Semantic Kernel for managing AI responses. How can I efficiently handle large responses within the token limits, or is there a better way to architect this process?</p>
</li>
<li><p><strong>Response Speed Optimization:</strong><br />
The application's response speed is slower than expected due to the multiple functions that need to be executed sequentially. What strategies can I use to optimize the response time, particularly when using Azure Functions and Semantic Kernel?</p>
</li>
<li><p><strong>Issues with Azure Search Indexers:</strong><br />
I am considering storing vectors in Azure Search, but I'm encountering errors when trying to create multiple indexers and indexes specific to each chat. Should I rely on Azure Search indexers for generating embeddings, or is it better to manually code the entire process (e.g., chunking, embedding, and storing)?</p>
</li>
</ol>
<p>Any insights, especially from those who have implemented similar architectures in Azure, would be highly appreciated. Thank you!</p>
| 1,437
|
|
implement RAG
|
How to filter results to LLM from graph database based on source file names?
|
https://stackoverflow.com/questions/78853538/how-to-filter-results-to-llm-from-graph-database-based-on-source-file-names
|
<p>I'm trying to build a Graph RAG with hybrid retrieval for technical documentation files. The answers need to be found for version specific documentation files. I'm trying to achieve this by filtering graph and vector queries based on file names. However, I'm unable to implement source file filtering for Graph RAG implementations using Neo4j graph database.</p>
<p>Specifically, I started off by using the code sample given here:
<a href="https://github.com/tomasonjo/blogs/blob/master/llm/enhancing_rag_with_graph.ipynb" rel="nofollow noreferrer">text</a>
and modified the code to load MS Word files. The code runs fine and the bot answers questions based on provided files. But, the bot is not picking up the right information from the right files for software version specific queries. So, I would like to limit the search space to information loaded on to the graph database from specific files. I tried modifying the graph database query (in the graph_retriever method) like this:</p>
<pre><code>"""CALL db.index.fulltext.queryNodes('entity', $query, {limit:2})
YIELD node,score
CALL {
WITH node
MATCH (node)-[r:!MENTIONS]->(neighbor)
WHERE node.source CONTAINS '12.34'
RETURN node.id + ' - ' + type(r) + ' -> ' + neighbor.id AS output
UNION ALL
WITH node
MATCH (node)<-[r:!MENTIONS]-(neighbor)
WHERE node.source CONTAINS '12.34'
RETURN neighbor.id + ' - ' + type(r) + ' -> ' + node.id AS output
}
RETURN output LIMIT 50
"""
</code></pre>
<p>(added the WHERE clause in 2 places). But, if I do that, the graph_retriever function doesn't produce any results. I'm wondering whether a version_number field needs to be added to each entry in the graph database. But, in the above sample code, the add_graph_documents method doesn't allow storing URL or file name information for each entry in the graph database. How do I filter based on source file names in the sample code? I'm stuck. Any help is much appreciated.</p>
|
<p>The <code>{limit: 2}</code> argument to <code>db.index.fulltext.queryNodes</code> produces at most 2 nodes for the rest of your query to use.</p>
<p>Either remove the <code>{limit: 2}</code> argument entirely, or increase the <code>2</code> to a comfortably large enough number to make it much more likely that you get some nodes that match your <code>WHERE</code> filters.</p>
| 1,438
|
implement RAG
|
LLamaIndex Workflow Context Memory Management
|
https://stackoverflow.com/questions/79085691/llamaindex-workflow-context-memory-management
|
<p>I am looking for a way to implement a RAG Chatbot which should keep the previous answer and questions from the current session in a short term memory and be able to answer followup question, I do not see anything from the documentation on how to implement that, I saw the chat engine documentation but saw no examples of implementing it in a workflow.</p>
<p>I was thinking whether to use external database with some time control mechanism and one of the nodes in the workflow to connect there and initiate the memory and pass along and for hte followup to have some human in the loop implementation which waits some time for followup quesiton and if nothing comes to delete the session but not sure whether this maskes sense as it seems overly complex :)</p>
<p>Looked through the workflow llamaindex documentation, looked through stackoverflow and google.</p>
|
<p>Kong Nopwattanapong published a blog post with regards to <a href="https://medium.com/credera-engineering/build-a-simple-rag-chatbot-with-langchain-b96b233e1b2a" rel="nofollow noreferrer">Building a simple RAG chatbot with LangChain</a>.</p>
<p>Nopwattanapong concluded, the model isn’t perfect and there are still many things to add to and improve the model in future. However, this will hopefully give you a basic understanding of how to create an RAG chatbot and how vector databases work.</p>
<p>Another example that might help you in <a href="https://codelabs.developers.google.com/codelabs/genai-db-retrieval-app#0" rel="nofollow noreferrer">Building an LLM and RAG-based chat application using AlloyDB AI and LangChain</a>. In this codelab you will learn how to deploy the GenAI Databases Retrieval Service and create a sample interactive application using the deployed environment. You may explore this github repository for more code level guide in <a href="https://github.com/GoogleCloudPlatform/genai-databases-retrieval-app/blob/main/README.md" rel="nofollow noreferrer">GenAI Databases Retrieval App</a>.</p>
| 1,439
|
implement RAG
|
LangChain error: "Groq does not currently support tool_choice='any'. Should be one of 'auto', 'none', or the name of the tool to call."
|
https://stackoverflow.com/questions/78926872/langchain-error-groq-does-not-currently-support-tool-choice-any-should-be-o
|
<p>Here's my issue:</p>
<p>I was using Groq API with LLama 3.1 70B model to implement agentic RAG through LangGraph. For that, I had to install <code>langchain_groq</code> library. I installed the most updated one using <code>pip install -U langchain_groq</code>.
Then I used the following code to load the model into a variable:</p>
<pre><code>from langchain_groq import ChatGroq
llm=ChatGroq(api_key=groq_api_key, model_name="llama-3.1-70b-versatile", temperature=0.3)
</code></pre>
<p>Now I implemented Agentic RAG with 3 tools to choose from using LangGraph.</p>
<pre><code>tools=[
fetch_MOM_Docs,
fetch_Action_Tracker,
final_answer
]
</code></pre>
<p>While using its <code>llm.bind_tools(tools, tool_choice='auto')</code> code, it is giving me the following error:</p>
<pre><code>ValueError: Groq does not currently support tool_choice='any'. Should be one of 'auto', 'none', or the name of the tool to call.
</code></pre>
<p>When I checked the code of <code>langchain_groq's bind_tools</code> function in the library, I came to understand that the library does not support <code>"any"</code> keyword for Groq. While it supports <code>any</code> for OpenAI and other services.</p>
<p><strong>BUT,</strong>
When I checked langchain's documentation it is clearly given in the 'Note' section of the documentation that <code>any</code> keyword is supported for Groq. See below given snapshot of the documentation. <a href="https://i.sstatic.net/nuCavhxP.png" rel="nofollow noreferrer"><img src="https://i.sstatic.net/nuCavhxP.png" alt="Langchain Documentation" /></a></p>
<p>Here's the link to the documentation: <a href="https://python.langchain.com/v0.1/docs/modules/model_io/chat/function_calling/" rel="nofollow noreferrer">https://python.langchain.com/v0.1/docs/modules/model_io/chat/function_calling/</a></p>
<p>I want to use Groq only for this purpose as it is free and fast. Am I missing something or is the Langchain's library not updated as per the documentation?</p>
<p>Help me how can I workaround this issue. I have tried using <code>"auto"</code> keyword, but the problem is, on some prompts the agent does not use any of the tools, while I certainly want it to use atleast one of the tools.</p>
<p>How can I make it choose one of the tools to retrieve information based on its decision making while not ending its cycle without using any tools?</p>
|
<p>You're looking at the LangChain <code>0.1</code> documentation while you're using the LangChain <code>0.2</code> SDK.</p>
<p>To check your LangChain Python SDK version, run the following command in the terminal:</p>
<pre><code>pip show langchain
</code></pre>
<p>For LLM provider specifics, see the <a href="https://python.langchain.com/v0.2/api_reference/reference.html" rel="nofollow noreferrer">LangChain <code>0.2</code> API reference</a>.</p>
<p>Further look into the <a href="https://python.langchain.com/v0.2/api_reference/groq/chat_models/langchain_groq.chat_models.ChatGroq.html" rel="nofollow noreferrer">LangChain's <code>0.2</code> Groq integration</a> shows that the error message you get is expected. The <code>tool_choice</code> parameter of the <code>bind_tools()</code> function accepts the following (<a href="https://python.langchain.com/v0.2/api_reference/groq/chat_models/langchain_groq.chat_models.ChatGroq.html#langchain_groq.chat_models.ChatGroq.bind_tools" rel="nofollow noreferrer">source</a>):</p>
<blockquote>
<p>bind_tools(tools: Sequence[Dict[str, Any] | Type[BaseModel] | Callable
| BaseTool], *, tool_choice: dict | str | Literal['auto', 'any',
'none'] | bool | None = None, **kwargs: Any) → Runnable[PromptValue |
str | Sequence[BaseMessage | List[str] | Tuple[str, str] | str |
Dict[str, Any]], BaseMessage][source]</p>
<p>Bind tool-like objects to this chat model.</p>
<p>Parameters:</p>
<ul>
<li><p>tools (Sequence[Dict[str, Any] | Type[BaseModel] | Callable | BaseTool]) – A list of tool definitions to bind to this chat model.
Supports any tool definition handled by
langchain_core.utils.function_calling.convert_to_openai_tool().</p>
</li>
<li><p>tool_choice (<strong>dict | str | Literal['auto', 'any', 'none'] | bool | None</strong>) – Which tool to require the model to call. Must be the name of
the single provided function, “auto” to automatically determine which
function to call with the option to not call any function, <strong>“any” to
enforce that some function is called</strong>, or a dict of the form: {“type”:
“function”, “function”: {“name”: <<tool_name>>}}.</p>
</li>
<li><p>**kwargs (Any) – Any additional parameters to pass to the Runnable constructor.</p>
</li>
</ul>
<p>Return type:</p>
<p>Runnable[PromptValue | str | Sequence[BaseMessage | List[str] |
Tuple[str, str] | str | Dict[str, Any]], BaseMessage]</p>
</blockquote>
<p>As you can see, you need to set the <code>tool_choice</code> parameter to <code>any</code> if you want to enforce that some function is called when using LangChain's <code>0.2</code> Groq integration.</p>
| 1,440
|
implement RAG
|
CSS | Ordered list in single vertical column above list item
|
https://stackoverflow.com/questions/32657851/css-ordered-list-in-single-vertical-column-above-list-item
|
<p>i'm looking to create an ordered list (decimal) in which all the items are rag-left aligned with their numerical header. for example:</p>
<blockquote>
<blockquote>
<p>List</p>
<p>1.</p>
<p>This is list item 1</p>
<p>2.</p>
<p>This is list item 2</p>
<p>3.</p>
<p>This is list item 3</p>
</blockquote>
</blockquote>
<p>I've been looking around but haven't found any way of implementing this. I still would like to use an since it scales better than manually entering numbers. Is there anyway to treat and list as a single col? </p>
|
<p>As @Imgonzalves pointed out --- </p>
<p>HTML</p>
<pre><code><ol>
<li><span>list item</span></li>
<li><span>list item</span></li>
<li><span>list item</span></li>
</ol>
</code></pre>
<p>CSS</p>
<pre><code>ol li span {
position: relative;
left: -20px;
display:block;
}
</code></pre>
<p>including his pen here: <a href="https://jsfiddle.net/lmgonzalves/z4gafdp7/" rel="nofollow">https://jsfiddle.net/lmgonzalves/z4gafdp7/</a></p>
| 1,441
|
implement RAG
|
Is there a way to interrupt text generation in an transformers LLM call?
|
https://stackoverflow.com/questions/78084171/is-there-a-way-to-interrupt-text-generation-in-an-transformers-llm-call
|
<p>I'm creating a RAG chatbot that uses the langchain and transformers libraries to generate responses to user queries using an LLM plugged into a vector index. The chatbot will live in a streamlit interface.</p>
<p>I want to implement a way for the user to interrupt the LLM's <code>generate()</code> function if the output is taking too long, seems to be incorrect, etc. I've explored using separate threads/processes but haven't had much luck - does anyone have any ideas?</p>
<p>I've tried using threads but couldn't figure out how to kill them with a certain trigger event (e.g., streamlit button). I also tried running the generation in a separate subprocess but it seemed to require loading the LLM separately (which doesn't seem memory efficient.) Let me know if I'm missing anything!</p>
| 1,442
|
|
implement RAG
|
Probably a really simple thing but I can't seem to pass an argument into my Javascript function
|
https://stackoverflow.com/questions/70411336/probably-a-really-simple-thing-but-i-cant-seem-to-pass-an-argument-into-my-java
|
<p>I am very new to JS I just created my very first web app but I am having trouble tidying up my code.</p>
<p>My HTML has 3 range sliders
I take the value from each and change the color of the thumb depending on that value (RAG).
It works fine the way I have implemented it but I have repeated myself quite a bit.</p>
<pre><code>document.getElementById(complex).addEventListener("change", complexityFunction);
document.getElementById(uncert).addEventListener("change", uncertaintyFunction);
document.getElementById(repeat).addEventListener("change", repetitionFunction);
function complexityFunction() {
var x = document.getElementById(complex).value;
if (x == 1) {
this.className = "green";
} else if (x == 2) {
this.className = "amber";
} else {
this.className = "red"
}
}
function uncertaintyFunction() {
var x = document.getElementById(uncert).value;
if (x == 1) {
this.className = "green";
} else if (x == 2) {
this.className = "amber";
} else {
this.className = "red"
}
}
function repetitionFunction() {
var x = document.getElementById(repeat).value;
if (x == 1) {
this.className = "green";
} else if (x == 2) {
this.className = "amber";
} else {
this.className = "red"
}
}
</code></pre>
<p>Here's what I have tried (amongst other things) which hasn't worked!:</p>
<pre><code>document.getElementById(complex).addEventListener("change", assessmentFunction(complex));
document.getElementById(uncert).addEventListener("change", assessmentFunction(uncert));
document.getElementById(repeat).addEventListener("change", assessmentFunction(repeat));
function assessmentFunction(argument) {
var x = document.getElementById(argument).value;
if (x == 1) {
this.className = "green";
} else if (x == 2) {
this.className = "amber";
} else {
this.className = "red"
}
}
</code></pre>
<p>Can somebody please help me out?</p>
| 1,443
|
|
implement RAG
|
OpenAIEmbeddings works fine but AzureOpenAIEmbeddings gives error: 'str' object has no attribute 'create'
|
https://stackoverflow.com/questions/78733721/openaiembeddings-works-fine-but-azureopenaiembeddings-gives-error-str-object
|
<p>I am implementing simple RAG using AzureOpenAI. It was working fine till I was directly using the OpenAIEmbeddings but when I deployed "text-embedding-ada-002" model on Azure and tried using the embeddings with that, it shows the error: 'str' object has no attribute 'create'</p>
<pre><code>import openai
from langchain_community.document_loaders import PyMuPDFLoader
from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores.faiss import FAISS
from langchain_openai import AzureOpenAIEmbeddings
loader = PyMuPDFLoader("test.pdf")
pages = loader.load_and_split()
#below works fine if I use it in place of Azure embeddings
embeddings = OpenAIEmbeddings(openai_api_key=api_key)
#below gives error
embeddings_AZ = AzureOpenAIEmbeddings(openai_api_key=OPENAI_API_KEY, deployment=OPENAI_EMBEDDING_MODEL_NAME, client="azure", chunk_size=1)
#here it gives error 'str' object has no attribute 'create'
pdfDocSearch = FAISS.from_documents(pages, embedding = embeddings_AZ)
</code></pre>
<p>I tried it with changing or passing multiple parameters like:</p>
<pre><code>AzureOpenAIEmbeddings(openai_api_key=OPENAI_API_KEY, document_model_name=OPENAI_EMBEDDING_MODEL_NAME, chunk_size=1, deployment=OPENAI_EMBEDDING_MODEL_NAME, client="azure")
</code></pre>
<p>Also I replaced AzureOpenAIEmbeddings with OpenAIEmbeddings as:</p>
<pre><code>OpenAIEmbeddings(openai_api_key=OPENAI_API_KEY, document_model_name=OPENAI_EMBEDDING_MODEL_NAME, chunk_size=1, deployment=OPENAI_EMBEDDING_MODEL_NAME, client="azure")
</code></pre>
<p>but nothing is working. It should not give error and Azure embeddings should also work as direct OpenAIEmbeddings are working.</p>
|
<p>I could able to figure out that I need to provide the proxy as it is running behind a firewall:</p>
<pre><code> embeddings = AzureOpenAIEmbeddings(
azure_deployment=os.getenv("AZURE_OPENAI_EMBEDDING_MODEL_NAME"),
openai_api_version=os.getenv("AZURE_OPENAI_API_VERSION"),
azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT"),
api_key=os.getenv("AZURE_OPENAI_API_KEY"),
http_client=httpx.Client(proxy=os.getenv("AZURE_OPENAI_HTTP_PROXY"))
)
</code></pre>
<p>#providing proxy fixed the issue.</p>
| 1,444
|
implement RAG
|
llama_index crashes with HuggingFaceEmbedding
|
https://stackoverflow.com/questions/78348493/llama-index-crashes-with-huggingfaceembedding
|
<p>I am trying to build a RAG pipeline using <code>llama_index</code>. One of the first steps is to choose an embedding model that will be used for a <code>VectorStoreIndex</code>. My current implementation looks like this:</p>
<pre class="lang-py prettyprint-override"><code>from llama_index.core import Settings
from llama_index.llms.openai import OpenAI
from llama_index.embeddings.huggingface import HuggingFaceEmbedding
# some other code
if embedding == Embedding.OPENAI:
Settings.embed_model = OpenAIEmbedding()
elif embedding == Embedding.BGE_SMALL_EN:
Settings.embed_model = HuggingFaceEmbedding (
model_name = "BAAI/bge-small-en-v1.5"
)
</code></pre>
<p>While <code>OpenAIEmbedding</code> works as expected, my Jupyter Notebook always crashes when using <code>HuggingFaceEmbedding</code>.</p>
<p>I have simply pip installed all required modules and started running the application. Is there anything else required to make this work? Do I need to download the embedding repository and place it locally? If so, where do I need to place it?</p>
|
<p>You have to install not just <code>pip install llama-index</code> and <code>pip install openai</code> but also <code>pip install llama-index-embeddings-huggingface</code>.</p>
<p>Alternatively, it is sufficient to install <code>llama-index</code> only, but then you have to adjust your import statement:</p>
<pre class="lang-py prettyprint-override"><code>from llama_index.legacy.embeddings import HuggingFaceEmbedding
</code></pre>
<p>As seen <a href="https://docs.llamaindex.ai/en/stable/examples/embeddings/huggingface/" rel="nofollow noreferrer">in the docs</a>.</p>
| 1,445
|
implement RAG
|
Stream output using VLLM
|
https://stackoverflow.com/questions/78815643/stream-output-using-vllm
|
<p>I am working on a RAG app, where I use LLMs to analyze various documents. I'm looking to improve the UX by streaming responses in real time.<br />
a snippet of my code:</p>
<pre class="lang-py prettyprint-override"><code>params = SamplingParams(temperature=TEMPERATURE,
min_tokens=128,
max_tokens=1024)
llm = LLM(MODEL_NAME,
tensor_parallel_size=4,
dtype="half",
gpu_memory_utilization=0.5,
max_model_len=27_000)
message = SYSTEM_PROMPT + "\n\n" + f"Question: {question}\n\nDocument: {document}"
response = llm.generate(message, params)
</code></pre>
<p>In its current form, <code>generate</code> method waits until the entire response is generated. I'd like to change this so that responses are streamed and displayed incrementally to the user, enhancing interactivity.</p>
<p>I was using <code>vllm==0.5.0.post1</code> when I first wrote that code.</p>
<p>Does anyone have experience with implementing streaming for <code>LLMs=Any</code>. Guidance or examples would be appreciated!</p>
|
<p><a href="https://docs.vllm.ai/en/stable/dev/engine/async_llm_engine.html#" rel="nofollow noreferrer">AsyncLLMEngine</a> will help you.</p>
<p>You can also refer to vLLM's <a href="https://github.com/vllm-project/vllm/blob/main/vllm/entrypoints/api_server.py#L56" rel="nofollow noreferrer">aip_server.py</a></p>
| 1,446
|
implement RAG
|
Playwright not displaying exception when locator not exists in DOM
|
https://stackoverflow.com/questions/76750187/playwright-not-displaying-exception-when-locator-not-exists-in-dom
|
<p>I am new to Playwright, I am trying to implement Playwritght +NUnit framework.
I currently facing 2 issues,</p>
<p>a. When I have give any invalid locator (eg: xpath, cssselector), Playwright not throwing exception message, it's continue next step, even I try in try/catch block it not print exception.</p>
<pre><code> _page.Locator("input#email1234").ClickAsync();
</code></pre>
<p>I have tried following code still it not displaying any error.</p>
<pre><code>await _page.Locator("input#email1234").ClickAsync(new LocatorClickOptions() { Trial = true });
</code></pre>
<p>b. I have used the waitForAsync conditions with 60sec, but playwright not wait until 60sec
to visible the locator in DOM, it's continue to next step, if I execute the script in debig mode and wait for 60sec then it displaying exception. Otherwise it continue to next step and closing the browser before display exception and test got passed.</p>
<pre><code>await GetElement(_page, "input#email").WaitForAsync(new()
{ State = WaitForSelectorState.Visible, Timeout =60000 });
</code></pre>
<p>Can someone please help me how address above issues.
Appreciate your help.</p>
<p>thanks
Rag</p>
|
<p>Option A with an <code>await</code> should work for you. Your code is not failing because we are not awaiting for the action that might fail.</p>
<pre><code>await _page.Locator("input#email1234").ClickAsync();
</code></pre>
| 1,447
|
implement RAG
|
How do I use MergeDataLoader to tolerate multiple files that could be in either PDF or docx format?
|
https://stackoverflow.com/questions/79370058/how-do-i-use-mergedataloader-to-tolerate-multiple-files-that-could-be-in-either
|
<p>I am writing a RAG chatbot that retrieves information from a given list of documents. The documents can be found in a set folder, and they could be either .pdf or .docx. I want to merge all the documents using the same vector store, but I am running into trouble with the MergeDataLoader because any given file could be either a .docx or a .pdf. Does anyone have a recommendation for solving this issue efficiently?</p>
<pre><code># Initialize an empty list to store loaded documents
docs = []
# Function to process a batch of PDF files
def process_pdf_batch(all_files):
batch_docs = []
for any_file_path in all_files:
if any_file_path.lower().endswith(".pdf"): # Implementation using one loader or the other
loader = PyPDFLoader(any_file_path)
elif any_file_path.lower().endswith(".docx"):
loader = Docx2txtLoader(any_file_path)
batch_docs.extend(loader.load())
# Implementation trying to combine both loaders
# pdf_loader = PyPDFLoader(any_file_path)
# doc_loader = Docx2txtLoader(any_file_path)
# all_loader = MergedDataLoader(loaders=[doc_loader, pdf_loader])
# batch_docs.extend(all_loader.load())
# pdf_loader = Docx2txtLoader(pdf_file_path)
# batch_docs.extend(pdf_loader.load())
return batch_docs
# Get the list of PDF files to process
pdf_files_to_process = []
for root, dirs, files in os.walk(root_directory):
pdf_files_to_process.extend([os.path.join(root, file) for file in files if (file.lower().endswith(".pdf") or file.lower().endswith(".docx"))])
total_files = len(pdf_files_to_process)
processed_files = 0
# Iterate through the PDF files in batches
for i in range(0, total_files, batch_size):
batch = pdf_files_to_process[i:i+batch_size]
batch_docs = list(process_pdf_batch(batch))
for batch_result in batch_docs:
docs.extend(batch_result)
processed_files += 1
print(f"Processed {processed_files} / {total_files} files")
</code></pre>
<p>I have tried using two different implementations: one where the individual types of loaders are used independently, and another where they are combined into a single loader.</p>
| 1,448
|
|
implement RAG
|
Uploading documents to Azure AI search
|
https://stackoverflow.com/questions/78153996/uploading-documents-to-azure-ai-search
|
<p>I am implementing RAG using azure AI search. I have created the index nd have 2605 document chunks in all to upload to the index. The peculiar behaviour that I have observed is :</p>
<ol>
<li>i cannot upload all 2605 chunks in one go.</li>
<li>I try passing these in batch sizes of 600, by loooping over and passing 600 in every iteration. I end up uploading only 2000. It loads 600 for three iterations but on fourth iteration it loads just 200 and then aborts.</li>
<li>if i increase the batch size to 900. I see from the output that all the chunks get loaded 900 in first two iterations and the remaining 805 in the third.</li>
</ol>
<p>I am trying to understand what goes on under the hood as I need to provision a code that would take care of uploads as small as 10 chunks to as large as 10000 chunks.
From documentation on website there are certain limits that Azure AI imposes. Like documents uploaded cannot be greater than 16 MB, The batch size cannot exceed 1000 per batch. These two together still don't explain why I am unable to load all the chunks with batch size of 600 whereas with 900 I am successful.</p>
<p>I was expecting it to load the chunks irrespective of the batch size.</p>
|
<p>I have used the Python SDK to upload documents, and they uploaded successfully. I tried with 3k and 10k documents, and it successfully uploaded all those documents to the index in one go.</p>
<p>Refer to the code below.</p>
<pre class="lang-py prettyprint-override"><code>import os
index_name = "hotels-2"
from azure.core.credentials import AzureKeyCredential
from azure.search.documents import SearchClient
search_client = SearchClient(service_endpoint, index_name, AzureKeyCredential(key))
def upload_document():
result = search_client.upload_documents(documents=hotels)
print("Upload of new document succeeded: {}".format(result[0].succeeded))
</code></pre>
<p>Output:</p>
<p><img src="https://i.imgur.com/MH5swNu.png" alt="Enter image description here" /></p>
<p>If you see, the length of the document is <code>10000</code>.</p>
<p>In the portal:</p>
<p><img src="https://i.imgur.com/rsKmVzM.png" alt="Enter image description here" /></p>
<p>For more information, refer to this <a href="https://github.com/Azure/azure-sdk-for-python/blob/azure-search-documents_11.4.0/sdk/search/azure-search-documents/samples/sample_crud_operations.py" rel="nofollow noreferrer">GitHub repository</a>.</p>
| 1,449
|
implement RAG
|
How to make dynamic API calls based on user input in a Gemini application python nlp?
|
https://stackoverflow.com/questions/78707861/how-to-make-dynamic-api-calls-based-on-user-input-in-a-gemini-application-python
|
<p>I'm working on a Gemini application where I need to make dynamic API calls based on user input. Specifically, I want to perform different API requests depending on the user's query. For example, if the user asks for the latest news, the application should make an API call to a news service. Similarly, if the user wants to know the current weather, the application should fetch data from a weather API.</p>
<p>Here's a basic outline of what I'm trying to achieve:</p>
<p>Capture the user's input.
Determine the type of request based on the input (e.g., news or weather).
Make the appropriate API call and return the data to the user.
I want to avoid using third-party libraries like RAG for this purpose. How can I implement this functionality in a clean and efficient way within my Gemini application?</p>
<p>And i dont want to use a approach like this '</p>
<pre><code>def handle_user_input(user_input):
if "news" in user_input:
# Call news API
pass
elif "weather" in user_input:
# Call weather API
pass
else:
return "I can't handle that request."
</code></pre>
|
<p>I suggest using a dictionary, basically what you u are looking to do is something called a "strategy pattern". You want to choose a different "strategy" in your case api based on different input.</p>
<p>so the way it will look is you have a dictionary {"news": "news-url", "weather": "weather-url"}</p>
<p>and then your code will be very simple</p>
<pre><code>user_input = ""
url = api_dict[user_input]
# make api call
</code></pre>
<p>and at the start of your program you need to initialize your dict. having it in this structure makes it so that you could even write a json file, parse it and have it used as your dictionary meaning you dont even need to edit code to update your available API's</p>
<p>At the end of the day when making a dynamic program, the options will always need to be inputted somehow, worst case is within the code like the if that you successfully understood is bad, as it makes the code long, unreadable and hard to modify.</p>
<p>An improvement like I suggested is creating that dynamic options map as a file or a python dictionary on the start of the program and using that.</p>
<p>the most dynamic option would be if the code is able to generate different responses to different input purely by the input. such an example would be gemini and chat-gpt where you can ask the some api route both "what is the weather in france" and "how much is 4 + 4" and it will provide a fitting answer (although not always correct)</p>
<p>EDIT (based on last comment)</p>
<p>Now I understand your question better. I cant say I understand your reasoning but the implementation is very simple, here is a chat I had with:</p>
<pre><code> chatGPT
here are a few api routes
http://test/weather
http://test/stocks
http://test/facts
in the next message I will put user input and based on the input you need to output the appropriate url
ChatGPT
Got it! Please provide the user input in your next message, and I'll give you the appropriate URL.
what should I wear tomorrow
ChatGPT
For the query "what should I wear tomorrow," the appropriate URL is:
http://test/weather
</code></pre>
<p>you will need chatGPT to alaways know the context for your URLs, meaning always provide or from a longer session have it available.</p>
<p>then you query with the user input and get your URL as a response</p>
<p>key issues:</p>
<ol>
<li>chat gpt makes stuff up, it can easily make stuff up, best case it will provide no url result for such a case, but im sure some edge cases will make it generate a url that doesnt exist in your context</li>
<li>expansive, using chat gpt to process user input simply to make a http request is expansive, it means a lot of requests, a lot of queries, a big context window (tokens) depending on your url count and input length. whatever you are building will be quite expansive to run</li>
</ol>
| 1,450
|
implement RAG
|
Problem Setting up a FAISS vector memory in Python with embeddings
|
https://stackoverflow.com/questions/79315980/problem-setting-up-a-faiss-vector-memory-in-python-with-embeddings
|
<p>I'm trying to run an LLM locally and feed it with the contents of a very large PDF. I have decided to try this via a RAG. For this I wanted to create a vectorstore, which contains the content of the pdf. however, I have a problem here when creating, which I can not solve, because I am still quite new in this area.</p>
<p>The problem is that I use FAISS and don't know how to pass my values to the .from_embeddings.
As a result, I have already received several errors.</p>
<p>My code looks like this:</p>
<pre><code>import re
import PyPDF2
from nltk.tokenize import sent_tokenize # After downloading resources
from sentence_transformers import SentenceTransformer
from langchain_community.vectorstores import FAISS # Updated import
def extract_text_from_pdf(pdf_path):
"""Extracts text from a PDF file.
Args:
pdf_path (str): Path to the PDF file.
Returns:
str: Extracted text from the PDF.
"""
with open(pdf_path, 'rb') as pdf_file:
reader = PyPDF2.PdfReader(pdf_file)
text = ""
for page_num in range(len(reader.pages)):
page = reader.pages[page_num]
text += page.extract_text()
return text
if __name__ == "__main__":
pdf_path = "" # Replace with your actual path
text = extract_text_from_pdf(pdf_path)
print("Text extracted from PDF file successfully.")
# Preprocess text to remove special characters
text = re.sub(r'[^\x00-\x7F]+', '', text) # Remove non-ASCII characters
sentences = sent_tokenize(text)
print(sentences) # Print the extracted sentences
# Filter out empty sentences (optional)
sentences = [sentence for sentence in sentences if sentence.strip()]
model_name = 'all-MiniLM-L6-v2'
model = SentenceTransformer(model_name)
# Ensure model.encode(sentences) returns a list of NumPy arrays
embeddings = model.encode(sentences)
vectorstore = FAISS.from_embeddings(embeddings, sentences_list=sentences)#problem here
print("Vector store created successfully.")
# Example search query (replace with your actual question)
query = "Was sind die wichtigsten Worte?"
search_results = vectorstore.search(query)
print("Search results:")
for result in search_results:
print(result)
</code></pre>
<p>If I execute the code as it is there, then the following error occurs:</p>
<pre><code>Traceback (most recent call last):
File “/Users/user/PycharmProjects/PythonProject/extract_pdf_text.py”, line 53, in <module>
vectorstore = FAISS.from_embeddings(embeddings, sentences_list=sentences)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
TypeError: FAISS.from_embeddings() missing 1 required positional argument: 'embedding'
</code></pre>
<p>However, if I now write <code>vectorstore = FAISS.from_embeddings(embedding= embeddings, sentences_list=sentences)</code>, then the text_embeddings parameter is missing</p>
<p>How do I have to fill the parameters so that I can use this, or is there a better way to implement this?</p>
| 1,451
|
|
implement RAG
|
Why does Bedrock and CrewAI produce incomplete responses?
|
https://stackoverflow.com/questions/78811050/why-does-bedrock-and-crewai-produce-incomplete-responses
|
<p>Im writing a crewAI backed by AWS Bedrock. application that generates code.</p>
<p>The issue Im seeing is that it produces incomplete responses. The code produce some python functions but will</p>
<ol>
<li>Produce an incomplete function that is syntacticly incorrect.</li>
<li>Produce not enough code to compelete the applciation. i.e. it misses some needed functions or code in the implementation.</li>
</ol>
<p>Im therefore trying to understand how bedrock and crewai works to get it to produce more complete answers.</p>
<p>Code snippets:</p>
<pre><code>MODEL_ID = "anthropic.claude-3-5-sonnet-20240620-v1:0"
bedrock = boto3.client(service_name="bedrock-runtime", region_name="us-east-1")
docs_tool = DirectoryReadTool(directory=DIRECTORY_PATH)
file_tool = FileReadTool()
model_kwargs = {
"max_tokens": 10000,
"temperature": 0.1,
"top_k": 250,
"top_p": 1,
"stop_sequences": ["\n\nHuman"],
}
agent_llm = ChatBedrock(client=bedrock,model_id=MODEL_ID,model_kwargs=model_kwargs)
def developer(tools):
""" An agent representing a senior developer"""
agent = Agent(
role='Senior application developer and team lead',
goal='Make sure the code produced by your team is at the required standard',
backstory=("You are a senior application developer"),
memory=True,
verbose=True,
allow_delegation=True,
llm=agent_llm,
tools=tools
)
return agent
def dev_task(tools, agent):
""" Tasks for writing unit tests"""
task = Task(
description = (
"Review this code and refactor it to make it more readable"
"do not return comments, feedback, breakdown or notes, just code."
),
expected_output = ("A refactored code base that is more readable"),
tools=tools,
agent= agent
)
return task
crew = Crew(
agents=agent,
tasks=tasks, # Optional: Sequential task execution is default
)
return crew, tasks
</code></pre>
<p>Ive tried to use other models like llama3 and Mistral but they both seem incompatible with crewai, throwing errors. It appears claude anthropic is the only compatiable one.
Ive tried using langchain but the vecotrisation takes too long when applying Rag on my machine. Not sure if there is a programmatic way to get bedrock to do it.</p>
<p>Is the tokenization too short?
Am I using crewAI properly?
Am I using Bedrock Properly?
Is the code base Im providing too big? Im asking the Directory tool to analyse a directory.</p>
<p>Thanks for your thoughts.</p>
<p>Ive tried to use other models like llama3 and Mistral but they both seem incompatible with crewai, throwing errors. It appears claude anthropic is the only compatiable one.
Ive tried using langchain but the vecotrisation takes too long when applying Rag on my machine. Not sure if there is a programmatic way to get bedrock to do it.</p>
| 1,452
|
|
implement RAG
|
Unable to ship my flutter app with a pre-built ObjectBox database
|
https://stackoverflow.com/questions/79626120/unable-to-ship-my-flutter-app-with-a-pre-built-objectbox-database
|
<p>I'm unable to <a href="https://docs.objectbox.io/faq#can-i-ship-my-app-with-a-pre-built-database" rel="nofollow noreferrer">ship my Flutter app with a pre-built database</a>. Below is my approach; <em><strong>it would be greatly appreciated if this intent of shipping a database and the steps involved are validated. Thank you.</strong></em></p>
<ol>
<li>Implement ObjectBox's <a href="https://docs.objectbox.io/on-device-vector-search#rag" rel="nofollow noreferrer">RAG / LangChain doc</a> which results in producing database files, <code>data.mdb</code> and <code>lock.mdb</code></li>
<li>Confirm data and schema using <a href="https://docs.objectbox.io/data-browser" rel="nofollow noreferrer">ObjectBox Admin</a> (Web App)</li>
<li><a href="https://docs.objectbox.io/getting-started#define-entity-classes" rel="nofollow noreferrer">Define entity class</a> in flutter app (Dart)</li>
<li><a href="https://docs.objectbox.io/getting-started#create-a-store" rel="nofollow noreferrer">Create a store</a> by specifying the directory where the database files reside</li>
<li>Run <code>dart run build_runner build</code> which produces <code>Objectbox-model.json</code> and <code>objectbox.g.dart</code> files</li>
<li>Run flutter app</li>
</ol>
<p>While building the app and attempting to launch it, the below exception is thrown:</p>
<pre><code>SchemaException (ObjectBoxException: failed to create store: DB's last index ID 1 is higher than 0 from model)
</code></pre>
<p>I then modify the object-model.json file as <a href="https://docs.objectbox.io/advanced/meta-model-ids-and-uids#resolving-meta-model-conflicts" rel="nofollow noreferrer">suggested</a> but just have more exceptions thrown at run-time:</p>
<pre><code>SchemaException (ObjectBoxException: failed to create store: Incoming **entity** ID 1:6036908649413638677 does not match existing UID 3239285334994872090)
SchemaException (ObjectBoxException: failed to create store: Incoming **property** ID 1:7508658071281774588 does not match existing UID 7911801750550807452)
</code></pre>
<p>No matter what I do to my flutter app's <code>models.dart</code> and <code>objectbox-model.json</code> files, <code>SchemaExceptions</code> are thrown.</p>
<p>As a sanity check, I produce the database files using <a href="https://docs.llamaindex.ai/en/stable/examples/vector_stores/ObjectBoxIndexDemo/" rel="nofollow noreferrer">LlamaIndex</a> but that throws a different kind of exception:</p>
<pre><code>StateError (Bad state: failed to create store: No index found for ID 1 (OBX_ERROR code 10001))
</code></pre>
|
<p>Before I answer: it's not officially supported to use an ObjectBox database (pre-)built with one SDK with a different SDK. There may be subtle differences in the platforms and SDKs.</p>
<p>Anyhow, if you want to attempt this (and again, it might not work): the "does not match existing UID" errors suggest you still need to make sure the UIDs in the model JSON match. You should be able to re-run the code generator for Dart afterwards to update the generated code to use the different UIDs.</p>
<p>You have linked to it, but maybe make sure to fully read <a href="https://docs.objectbox.io/advanced/meta-model-ids-and-uids" rel="nofollow noreferrer">the docs on IDs and UIDs</a> to understand what is happening here.</p>
| 1,453
|
implement RAG
|
Azure Cognitive Search - Filter is not working
|
https://stackoverflow.com/questions/77996066/azure-cognitive-search-filter-is-not-working
|
<p>I have RAG and am trying to implement filtering by keywords/phrases as shown below:</p>
<pre><code> public SearchOptions? CreateSearchOptions( int searchTypeInt,
int k,
ReadOnlyMemory<float> embeddings,
ReadOnlyMemory<float> namedEntitiesEmbeddings,
string filter,
FilterAction filterAction)
{
_logger.LogInformation("CreateSearchOptions entered");
SearchOptions? searchOptions = null;
try
{
SearchType searchType = (SearchType)searchTypeInt;
System.FormattableString formattableStr = $"SegmentText ct '{filter}'";
if (!String.IsNullOrWhiteSpace(filter))
{
if (filterAction == FilterAction.Include)
{
formattableStr = $"search.ismatch({filter}, 'SegmentText')";
}
else if (filterAction == FilterAction.Exclude)
{
formattableStr = $"NOT(search.ismatch({filter}, 'SegmentText'))";
}
}
searchOptions = new SearchOptions
{
//Filter = filter, will be set later
Size = k,
// fields to retrieve, if not specified then all are retrieved if retrievable
Select = { "SegmentText", "NamedEntities", "docId", "segmentId", "Source", "TimeSrcModified", "TimeSrcCreated", "TimeIngested" },
//SearchMode = SearchMode.Any, TBD!!!
Filter = SearchFilter.Create(formattableStr)
};
if ((searchType & SearchType.Vector) == SearchType.Vector)
{
searchOptions.VectorSearch = new VectorSearchOptions();
VectorizedQuery vq = new VectorizedQuery(embeddings) { KNearestNeighborsCount = k, Fields = { "SegmentTextVector" } };
searchOptions.VectorSearch.Queries.Add(vq);
if (namedEntitiesEmbeddings.Length > 0)
{
vq = new VectorizedQuery(namedEntitiesEmbeddings) { KNearestNeighborsCount = k, Fields = { "SegmentNamedEntitiesVector" } };
searchOptions.VectorSearch.Queries.Add(vq);
}
}
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
return null;
}
return searchOptions;
}
</code></pre>
<p>The problem is that my 'documents' are actually chunks of a document and are 500-700 tokens length. The vector search returns 5 relevant chunks out of 11 chunks that constitute entire file. In my test case it is my resume. It works fine, but adding "Include" filter does not do much. If user prompt is: What projects the developer worked on in his career" and I set the filter to "Outlook" to indicate that I want the list of projects related to MS Outlook, it still gives me variety of projects, not only Outlook related. Because I am passing 5 results of vector search into OpenAI Completion API and these chunks also include some other projects besides Outlook. So what the solution would be? (I'm talking about filter here besides specifically asking "List Outlook projects only that developer worked on")</p>
|
<p>I'm not sure what the "SearchFilter.Create()" function does, but assuming it doesn't rewrite the input string, the "ct" operator used in</p>
<pre><code>$"SegmentText ct '{filter}'"
</code></pre>
<p>doesn't exist. The filter language is documented here: <a href="https://learn.microsoft.com/en-us/azure/search/search-query-odata-filter" rel="nofollow noreferrer">https://learn.microsoft.com/en-us/azure/search/search-query-odata-filter</a></p>
| 1,454
|
implement RAG
|
I am using LangChain4j to develop a knowledge base and encountered the "different vector dimensions 1024 and 384"
|
https://stackoverflow.com/questions/79557012/i-am-using-langchain4j-to-develop-a-knowledge-base-and-encountered-the-differen
|
<p>I want to know if there are any other settings required for pgvector or what content needs to be set in the code to enable pgvector to support higher vector dimensions. I found on the official website that pgvector can support vector dimensions up to 2000.The pgvector version is pgvector/pgvector:pg17</p>
<p>This model supports vector values of 1024. This is the Alibaba Cloud dashscope model</p>
<pre class="lang-yaml prettyprint-override"><code>langchain4j:
community:
dashscope:
chat-model:
model-name: deepseek-r1
embedding-model:
model-name: text-embedding-v3
</code></pre>
<p>This is the POM file, the version of the related dependencies</p>
<pre class="lang-xml prettyprint-override"><code><maven.compiler.source>21</maven.compiler.source>
<maven.compiler.target>21</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<lombok.version>1.18.30</lombok.version>
<junit.version>5.11.4</junit.version>
<log4j2.version>2.24.3</log4j2.version>
<springboot.version>3.3.2</springboot.version>
<postgresql.version>42.3.8</postgresql.version>
<mybatis-plus.version>3.5.8</mybatis-plus.version>
<oapi-sdk>2.4.8</oapi-sdk>
<caffeine.version>3.1.8</caffeine.version>
<httpclient.version>5.4.1</httpclient.version>
<springai.version>1.0.0-SNAPSHOT</springai.version>
<langchain.version>1.0.0-beta1</langchain.version>
</code></pre>
<p>Initialization EmbeddingStore and PgVectorEmbeddingStore</p>
<pre><code>@Bean
public Assistant init(EmbeddingStore<TextSegment> embeddingStore) {
return AiServices.builder(Assistant.class)
.chatMemoryProvider(memoryId -> MessageWindowChatMemory.withMaxMessages(10))
.contentRetriever(EmbeddingStoreContentRetriever.from(embeddingStore))
.chatLanguageModel(chatLanguageModel).build();
}
@Bean
public EmbeddingStore<TextSegment> initEmbeddingStore() {
return PgVectorEmbeddingStore.builder()
.table(pgConfig.getTable())
.dropTableFirst(true)
.createTable(true)
.host(pgConfig.getHost())
.port(pgConfig.getPort())
.user(pgConfig.getUser())
.password(pgConfig.getPassword())
.dimension(1024)
.database(pgConfig.getDatabase())
.build();
}
</code></pre>
<p>The first step was to load the file into the vector table in pgvector through the load interface, and this step was successful. In the second part, I called assistant.chat through the/high/chat interface to answer my question and implement the RAG function, but the second is fail</p>
<pre><code>@GetMapping("/load")
public String load(@RequestParam(value = "maxSegmentSizeInChars",required = false,defaultValue = "50") int maxSegmentSizeInChars
, @RequestParam(value = "maxOverlapSizeInChars",required = false ,defaultValue = "10") int maxOverlapSizeInChars) {
List<Document> documents = FileSystemDocumentLoader.loadDocuments("D:\\work\\lecture-langchain-20250525\\documents");
// EmbeddingStoreIngestor.ingest(documents,embeddingStore);
EmbeddingStoreIngestor.builder().embeddingStore(embeddingStore)
.embeddingModel(embeddingModel)
.documentSplitter(new DocumentByLineSplitter(maxSegmentSizeInChars, maxOverlapSizeInChars))
.build().ingest(documents);
return "success";
}
@GetMapping("/high/chat")
public String lowChat(@RequestParam(value = "message") String message) {
return assistant.chat(message);
}
</code></pre>
<p>Error message</p>
<pre class="lang-none prettyprint-override"><code>org.postgresql.util.PSQLException: ERROR: different vector dimensions 1024 and 384
at org.postgresql.core.v3.QueryExecutorImpl.receiveErrorResponse(QueryExecutorImpl.java:2675) ~[postgresql-42.3.8.jar:42.3.8]
at org.postgresql.core.v3.QueryExecutorImpl.processResults(QueryExecutorImpl.java:2365) ~[postgresql-42.3.8.jar:42.3.8]
at org.postgresql.core.v3.QueryExecutorImpl.execute(QueryExecutorImpl.java:355) ~[postgresql-42.3.8.jar:42.3.8]
at org.postgresql.jdbc.PgStatement.executeInternal(PgStatement.java:490) ~[postgresql-42.3.8.jar:42.3.8]
at org.postgresql.jdbc.PgStatement.execute(PgStatement.java:408) ~[postgresql-42.3.8.jar:42.3.8]
at org.postgresql.jdbc.PgPreparedStatement.executeWithFlags(PgPreparedStatement.java:167) ~[postgresql-42.3.8.jar:42.3.8]
at org.postgresql.jdbc.PgPreparedStatement.executeQuery(PgPreparedStatement.java:119) ~[postgresql-42.3.8.jar:42.3.8]
at dev.langchain4j.store.embedding.pgvector.PgVectorEmbeddingStore.search(PgVectorEmbeddingStore.java:294) ~[langchain4j-pgvector-1.0.0-beta1.jar:na]
at dev.langchain4j.rag.content.retriever.EmbeddingStoreContentRetriever.retrieve(EmbeddingStoreContentRetriever.java:241) ~[langchain4j-core-1.0.0-beta1.jar:na]
at dev.langchain4j.rag.DefaultRetrievalAugmentor.process(DefaultRetrievalAugmentor.java:182) ~[langchain4j-core-1.0.0-beta1.jar:na]
at dev.langchain4j.rag.DefaultRetrievalAugmentor.augment(DefaultRetrievalAugmentor.java:162) ~[langchain4j-core-1.0.0-beta1.jar:na]
at dev.langchain4j.service.DefaultAiServices$1.invoke(DefaultAiServices.java:140) ~[langchain4j-1.0.0-beta1.jar:na]
at jdk.proxy2/jdk.proxy2.$Proxy60.chat(Unknown Source) ~[na:na]
at com.xmin.lecture.rag.RagAPI.lowChat(RagAPI.java:31) ~[classes/:na]
at java.base/jdk.internal.reflect.DirectMethodHandleAccessor.invoke(DirectMethodHandleAccessor.java:103) ~[na:na]
at java.base/java.lang.reflect.Method.invoke(Method.java:580) ~[na:na]
at org.springframework.web.method.support.InvocableHandlerMethod.doInvoke(InvocableHandlerMethod.java:255) ~[spring-web-6.1.11.jar:6.1.11]
at org.springframework.web.method.support.InvocableHandlerMethod.invokeForRequest(InvocableHandlerMethod.java:188) ~[spring-web-6.1.11.jar:6.1.11]
at org.springframework.web.servlet.mvc.method.annotation.ServletInvocableHandlerMethod.invokeAndHandle(ServletInvocableHandlerMethod.java:118) ~[spring-webmvc-6.1.11.jar:6.1.11]
at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.invokeHandlerMethod(RequestMappingHandlerAdapter.java:926) ~[spring-webmvc-6.1.11.jar:6.1.11]
at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.handleInternal(RequestMappingHandlerAdapter.java:831) ~[spring-webmvc-6.1.11.jar:6.1.11]
at org.springframework.web.servlet.mvc.method.AbstractHandlerMethodAdapter.handle(AbstractHandlerMethodAdapter.java:87) ~[spring-webmvc-6.1.11.jar:6.1.11]
at org.springframework.web.servlet.DispatcherServlet.doDispatch(DispatcherServlet.java:1089) ~[spring-webmvc-6.1.11.jar:6.1.11]
at org.springframework.web.servlet.DispatcherServlet.doService(DispatcherServlet.java:979) ~[spring-webmvc-6.1.11.jar:6.1.11]
at org.springframework.web.servlet.FrameworkServlet.processRequest(FrameworkServlet.java:1014) ~[spring-webmvc-6.1.11.jar:6.1.11]
at org.springframework.web.servlet.FrameworkServlet.doGet(FrameworkServlet.java:903) ~[spring-webmvc-6.1.11.jar:6.1.11]
at jakarta.servlet.http.HttpServlet.service(HttpServlet.java:564) ~[tomcat-embed-core-10.1.26.jar:10.1.26]
at org.springframework.web.servlet.FrameworkServlet.service(FrameworkServlet.java:885) ~[spring-webmvc-6.1.11.jar:6.1.11]
at jakarta.servlet.http.HttpServlet.service(HttpServlet.java:658) ~[tomcat-embed-core-10.1.26.jar:10.1.26]
at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:195) ~[tomcat-embed-core-10.1.26.jar:10.1.26]
at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:140) ~[tomcat-embed-core-10.1.26.jar:10.1.26]
at org.apache.tomcat.websocket.server.WsFilter.doFilter(WsFilter.java:51) ~[tomcat-embed-websocket-10.1.26.jar:10.1.26]
at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:164) ~[tomcat-embed-core-10.1.26.jar:10.1.26]
at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:140) ~[tomcat-embed-core-10.1.26.jar:10.1.26]
at org.springframework.web.filter.RequestContextFilter.doFilterInternal(RequestContextFilter.java:100) ~[spring-web-6.1.11.jar:6.1.11]
at org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:116) ~[spring-web-6.1.11.jar:6.1.11]
at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:164) ~[tomcat-embed-core-10.1.26.jar:10.1.26]
at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:140) ~[tomcat-embed-core-10.1.26.jar:10.1.26]
at org.springframework.web.filter.FormContentFilter.doFilterInternal(FormContentFilter.java:93) ~[spring-web-6.1.11.jar:6.1.11]
at org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:116) ~[spring-web-6.1.11.jar:6.1.11]
at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:164) ~[tomcat-embed-core-10.1.26.jar:10.1.26]
at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:140) ~[tomcat-embed-core-10.1.26.jar:10.1.26]
at org.springframework.web.filter.CharacterEncodingFilter.doFilterInternal(CharacterEncodingFilter.java:201) ~[spring-web-6.1.11.jar:6.1.11]
at org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:116) ~[spring-web-6.1.11.jar:6.1.11]
at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:164) ~[tomcat-embed-core-10.1.26.jar:10.1.26]
at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:140) ~[tomcat-embed-core-10.1.26.jar:10.1.26]
at org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:167) ~[tomcat-embed-core-10.1.26.jar:10.1.26]
at org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:90) ~[tomcat-embed-core-10.1.26.jar:10.1.26]
at org.apache.catalina.authenticator.AuthenticatorBase.invoke(AuthenticatorBase.java:483) ~[tomcat-embed-core-10.1.26.jar:10.1.26]
at org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:115) ~[tomcat-embed-core-10.1.26.jar:10.1.26]
at org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:93) ~[tomcat-embed-core-10.1.26.jar:10.1.26]
at org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:74) ~[tomcat-embed-core-10.1.26.jar:10.1.26]
at org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:344) ~[tomcat-embed-core-10.1.26.jar:10.1.26]
at org.apache.coyote.http11.Http11Processor.service(Http11Processor.java:389) ~[tomcat-embed-core-10.1.26.jar:10.1.26]
at org.apache.coyote.AbstractProcessorLight.process(AbstractProcessorLight.java:63) ~[tomcat-embed-core-10.1.26.jar:10.1.26]
at org.apache.coyote.AbstractProtocol$ConnectionHandler.process(AbstractProtocol.java:904) ~[tomcat-embed-core-10.1.26.jar:10.1.26]
at org.apache.tomcat.util.net.NioEndpoint$SocketProcessor.doRun(NioEndpoint.java:1741) ~[tomcat-embed-core-10.1.26.jar:10.1.26]
at org.apache.tomcat.util.net.SocketProcessorBase.run(SocketProcessorBase.java:52) ~[tomcat-embed-core-10.1.26.jar:10.1.26]
at org.apache.tomcat.util.threads.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1190) ~[tomcat-embed-core-10.1.26.jar:10.1.26]
at org.apache.tomcat.util.threads.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:659) ~[tomcat-embed-core-10.1.26.jar:10.1.26]
at org.apache.tomcat.util.threads.TaskThread$WrappingRunnable.run(TaskThread.java:63) ~[tomcat-embed-core-10.1.26.jar:10.1.26]
at java.base/java.lang.Thread.run(Thread.java:1583) ~[na:na]
</code></pre>
<p>I have tried changing the model or modifying the parameters, but due to my limited knowledge of PgVector, I would like to know how to set PgVector to solve this problem</p>
|
<p>you need to change <code>.dimension(1024)</code> to <code>.dimension(384)</code>.</p>
<p>You can always get the dimention of your <code>EmbeddingModel</code> by calling <code>EmbeddingModel.dimension()</code>.</p>
| 1,455
|
implement RAG
|
Azure AI search fields mapping JSON and retrievable fields
|
https://stackoverflow.com/questions/78546836/azure-ai-search-fields-mapping-json-and-retrievable-fields
|
<p>I'm currently implementing RAG on Azure using OpenAI and Azure AI Search, formerly known as Cognitive Services. I have around 50-65 JSON files that I need to search on my enterprise data. It turns out that in the referencing of the chatbot, I'm only getting the text "citation" and I'm trying to retrieve the DOI, which is the URL to the document online, and the title of the scientific article. This files are saved as .txt.</p>
<p>I have formatted my JSON file in this manner where the keys 'content' and 'title' are the only ones I want to perform a semantic search on and also make retrievable, while I just want the DOI (URL) to be retrievable.</p>
<pre><code>{
"content": "The human eye is a complex organ responsible for vision, capturing light and converting it into neural signals for the brain to interpret. It consists of multiple parts, including the cornea, lens, and retina, each playing a vital role in the process of seeing.",
"date": "2023-07-15",
"Title": "The Magic of Vision",
"editorial_house": "MIT Research Meds and Public Health",
"doi": "https://doi.org/10.1234",
"author": "Dr. John Mayer"
}
</code></pre>
<p>Nonetheless when I'm on the Azure AI search page I never get my other fields to be selected in metadata:</p>
<p><a href="https://i.sstatic.net/kEjkYFSb.png" rel="nofollow noreferrer"><img src="https://i.sstatic.net/kEjkYFSb.png" alt="enter image description here" /></a></p>
<p>As you can see, only 'content' appears and I still get this unappealing citation in the foot references of my searches. How can I make my data retrievable in the way I want?</p>
<p>As I'm not using code to do this, only the Azure Studio web, I'm not sure if the only way to do that is by using code.</p>
<p>My desired output is something like this:</p>
<p><a href="https://i.sstatic.net/8q7jeaTK.png" rel="nofollow noreferrer"><img src="https://i.sstatic.net/8q7jeaTK.png" alt="enter image description here" /></a></p>
<p>Is this possible? Is it possible using the Azure studio or just doing code?</p>
<h2>Update</h2>
<p>I'm setting up the custom mappings like this:</p>
<p><a href="https://i.sstatic.net/AOyW3f8J.png" rel="nofollow noreferrer"><img src="https://i.sstatic.net/AOyW3f8J.png" alt="enter image description here" /></a></p>
<p>Nonetheless while I'm getting the correct title and content of the citations panel <strong>I'M missing the DOI</strong> which is the URL of the publication. Is there something I'm doing wrong??</p>
<p><a href="https://i.sstatic.net/HjIwR4Oy.png" rel="nofollow noreferrer"><img src="https://i.sstatic.net/HjIwR4Oy.png" alt="enter image description here" /></a></p>
|
<p>Import data and with index definition both way you can do.</p>
<p>In portal, after you clicking on import data you will get an option <strong>connect to your data</strong> there you need to configure parsing mode as json.</p>
<p><img src="https://i.imgur.com/m3sXom5.png" alt="enter image description here" /></p>
<p>then you will get the correct fields.
<img src="https://i.imgur.com/hMiJ2gU.png" alt="enter image description here" /></p>
<p>Here you can remove whichever field you don't want.</p>
<p>Another method is create index with custom definition like below.</p>
<pre class="lang-json prettyprint-override"><code>[
{
"name": "content",
"type": "Edm.String",
"searchable": true,
"filterable": false,
"retrievable": true,
"stored": true,
"sortable": false,
"facetable": false,
"key": false,
"indexAnalyzer": null,
"searchAnalyzer": null,
"analyzer": "standard.lucene",
"normalizer": null,
"dimensions": null,
"vectorSearchProfile": null,
"vectorEncoding": null,
"synonymMaps": []
},
{
"name": "date",
"type": "Edm.DateTimeOffset",
"searchable": false,
"filterable": false,
"retrievable": true,
"stored": true,
"sortable": false,
"facetable": false,
"key": false,
"indexAnalyzer": null,
"searchAnalyzer": null,
"analyzer": null,
"normalizer": null,
"dimensions": null,
"vectorSearchProfile": null,
"vectorEncoding": null,
"synonymMaps": []
},
{
"name": "Title",
"type": "Edm.String",
"searchable": true,
"filterable": false,
"retrievable": true,
"stored": true,
"sortable": false,
"facetable": false,
"key": false,
"indexAnalyzer": null,
"searchAnalyzer": null,
"analyzer": "standard.lucene",
"normalizer": null,
"dimensions": null,
"vectorSearchProfile": null,
"vectorEncoding": null,
"synonymMaps": []
},
{
"name": "editorial_house",
"type": "Edm.String",
"searchable": true,
"filterable": false,
"retrievable": true,
"stored": true,
"sortable": false,
"facetable": false,
"key": false,
"indexAnalyzer": null,
"searchAnalyzer": null,
"analyzer": "standard.lucene",
"normalizer": null,
"dimensions": null,
"vectorSearchProfile": null,
"vectorEncoding": null,
"synonymMaps": []
},
{
"name": "doi",
"type": "Edm.String",
"searchable": true,
"filterable": false,
"retrievable": true,
"stored": true,
"sortable": false,
"facetable": false,
"key": false,
"indexAnalyzer": null,
"searchAnalyzer": null,
"analyzer": "standard.lucene",
"normalizer": null,
"dimensions": null,
"vectorSearchProfile": null,
"vectorEncoding": null,
"synonymMaps": []
},
{
"name": "author",
"type": "Edm.String",
"searchable": true,
"filterable": false,
"retrievable": true,
"stored": true,
"sortable": false,
"facetable": false,
"key": false,
"indexAnalyzer": null,
"searchAnalyzer": null,
"analyzer": "standard.lucene",
"normalizer": null,
"dimensions": null,
"vectorSearchProfile": null,
"vectorEncoding": null,
"synonymMaps": []
},
{
"name": "metadata_storage_size",
"type": "Edm.Int64",
"searchable": false,
"filterable": false,
"retrievable": true,
"stored": true,
"sortable": false,
"facetable": false,
"key": false,
"indexAnalyzer": null,
"searchAnalyzer": null,
"analyzer": null,
"normalizer": null,
"dimensions": null,
"vectorSearchProfile": null,
"vectorEncoding": null,
"synonymMaps": []
},
{
"name": "metadata_storage_path",
"type": "Edm.String",
"searchable": true,
"filterable": false,
"retrievable": true,
"stored": true,
"sortable": false,
"facetable": false,
"key": true,
"indexAnalyzer": null,
"searchAnalyzer": null,
"analyzer": "standard.lucene",
"normalizer": null,
"dimensions": null,
"vectorSearchProfile": null,
"vectorEncoding": null,
"synonymMaps": []
}
]
</code></pre>
<p>next configure indexer like below.</p>
<p><img src="https://i.imgur.com/tWndkIK.png" alt="enter image description here" /></p>
<p>After saving reset and run the indexer.</p>
| 1,456
|
implement RAG
|
Optimizing Django ORM for Hybrid Queries (PostgreSQL + Vector Similarity Search)
|
https://stackoverflow.com/questions/79569409/optimizing-django-orm-for-hybrid-queries-postgresql-vector-similarity-search
|
<p>I'm implementing a RAG (Retrieval-Augmented Generation) system that requires combining traditional Django ORM filtering with vector similarity searches. The specific workflow needs to:</p>
<p>First filter products by standard relational fields (e.g., category="books")</p>
<p>Then perform vector similarity search on just that filtered subset of product descriptions</p>
<p>Current Implementation and Challenges:</p>
<pre><code># Current inefficient approach (two separate operations)
books = Product.objects.filter(category="books") # Initial DB query
vectors = get_embeddings([b.description for b in books]) # Expensive embedding generation
results = faiss_search(vectors, query_embedding) # Vector search
</code></pre>
<p>Key problems with this approach:</p>
<ul>
<li>Requires loading all filtered records into memory</li>
<li>Makes two separate passes over the data</li>
<li>Doesn't leverage PostgreSQL's native capabilities when using pgvector</li>
</ul>
<p>What I've Tried:</p>
<ol>
<li>Raw SQL with pgvector:</li>
</ol>
<pre><code>query = """
SELECT id FROM products
WHERE category = 'books'
ORDER BY description_embedding <=> %s
LIMIT 10
"""
results = Product.objects.raw(query, [query_embedding])
</code></pre>
<p>Problem: Loses Django ORM benefits like chaining, model methods.</p>
<ol start="2">
<li>django-pgvector extension:</li>
</ol>
<pre><code>from pgvector.django import L2Distance
books = Product.objects.annotate(
distance=L2Distance('description_embedding', query_embedding)
).filter(category="books").order_by('distance')[:10]
</code></pre>
<p>Problem: Doesn't scale well with complex filter conditions</p>
<p>Expected Solution:</p>
<p>Looking for a way to:</p>
<ol>
<li>Maintain Django ORM's expressiveness for initial filtering.</li>
<li>Efficiently combine with vector search on the filtered subset.</li>
<li>Avoid loading all records into memory.</li>
<li>Preferably stay within Django's ecosystem.</li>
</ol>
<p>Environment:</p>
<ul>
<li>Django 5.0</li>
<li>PostgreSQL 15 + pgvector</li>
<li>Python 3.11</li>
</ul>
| 1,457
|
|
implement RAG
|
Inquiry About Intent Feature in OpenAI and Azure AI Search Integration
|
https://stackoverflow.com/questions/79007855/inquiry-about-intent-feature-in-openai-and-azure-ai-search-integration
|
<p>I am interested in understanding the logic behind the intent feature in the integration between OpenAI's chat completions and Azure AI Search. Specifically, I noticed that when appending and sending chat history for retrieval-augmented generation (RAG), there is a feature in the response named "intent." This output appears to be a reformulated query that is sent to the AI search to ensure it receives a meaningful request, allowing the search engine to complete its task effectively.</p>
<p>Take a look:</p>
<pre><code>completion = client.chat.completions.create(
messages=[
{"role": "user", "content": "Who is the first man to land on the moon?"},
{"role": "assistant", "content": "The first man to land on the moon was Neil Armstrong."},
{"role": "user", "content": "How old was he at that time?"}
],
model=deployment,
extra_body={
"dataSources": [
{
"type": "AzureCognitiveSearch",
"parameters": {
"endpoint": os.environ["SEARCH_ENDPOINT"],
"key": os.environ["SEARCH_KEY"],
"indexName": os.environ["SEARCH_INDEX_NAME"],
}
}
]
}
)
</code></pre>
<p>Not Only the chat completion returns the correct answer which is 38 years old but also return an 'intent' feature :</p>
<pre><code>print(completion.choices[0].message.context['intent'])
["How old was Neil Armstrong when he landed on the moon?", "What was Neil Armstrong's age when he landed on the moon?", "How old was Neil Armstrong when he was on the moon?"]
</code></pre>
<p>I’m very interested in understanding this mechanism, as I’m working with a stateless LangChain agent, and I would love to implement something similar.</p>
<p>I would like to know what prompt OpenAI uses to reformulate the query and send it to Azure AI Search using the "intent" feature. I want to be able to replicate this functionality using a prompt or some tools.</p>
<p>I am looking for a solution that allows me to summarize user inputs and send those reformulated queries to a LangChain agent. Is there any documentation or report that explains how to implement this intent feature in a standard chat completion? Additionally, are there any prompts used by OpenAI to reformulate and query the questions?</p>
|
<p>It is the detected intent from chat history, check <a href="https://learn.microsoft.com/en-us/azure/ai-services/openai/references/on-your-data?tabs=python#context" rel="nofollow noreferrer">this</a>
Getting intent considering all the chat history you are giving.</p>
<p>azure openai did not provided how it is creating intent publicly.
So, you either use intent detection model or a prompt with examples to create intent.</p>
<p>Here is an example using prompt.</p>
<pre><code>import json
messages=[
{"role": "user", "content": "Who is the first man to land on the moon?"},
{"role": "assistant", "content": "The first man to land on the moon was Neil Armstrong."},
{"role": "user", "content": "How old was he at that time?"}
]
userquery = ','.join([json.dumps(i) for i in messages])
reformulation_prompt = """
You are an intelligent assistant tasked with helping users retrieve information from a database. The user may ask ambiguous, incomplete, or vague questions. Your task is to reformulate their query in a clear and precise way that can be sent to a search engine to retrieve the most relevant documents.
Here are some examples:
- User input: {"role": "user","content": "what is vector profiles?"}
Reformulated queries: "What are vector profiles?", "Definition of vector profiles", "How do vector profiles work?"
Now, please reformulate the following user input, also give 2 to 3 Reformulated queries:
User input:""" + userquery + """
Reformulated query:
"""
t = client.completions.create(model=deployment,prompt=reformulation_prompt)
t.choices[0].text
</code></pre>
<p>and output:</p>
<p><img src="https://i.imgur.com/bkRyimo.png" alt="enter image description here" /></p>
<p>Now you use this response in your langchain agent.</p>
| 1,458
|
implement RAG
|
Fine-Tuning LLMs: CUDA OOM Errors Despite Various Optimization Techniques
|
https://stackoverflow.com/questions/78949634/fine-tuning-llms-cuda-oom-errors-despite-various-optimization-techniques
|
<p>I'm working on fine-tuning an LLM to build a fantasy football league model. The goal is to have the model output a team with high potential (hopefully) given a round of games. I have built an RAG dataset and implemented custom loss functions and metrics to fine-tune the model.</p>
<p><strong>Problem</strong>: Regardless of the model I try to fine-tune, I consistently encounter a CUDA Out Of Memory (OOM) error. I've attempted to fine-tune various models, starting with Mistral-7B and going down to models with as few as 410M parameters (<em>EleutherAI/pythia-410m,</em> bigscience/bloomz-560m*)*. However, the OOM issue persists even with smaller models.</p>
<p><strong>Environment Details</strong>:</p>
<ul>
<li><p>EC2 Instance: g5.2xlarge</p>
</li>
<li><p>GPU: A100 with 24 GB VRAM</p>
</li>
<li><p>CPU RAM: 32 GB</p>
</li>
</ul>
<p><strong>What I Tried</strong>:</p>
<ol>
<li><p>Lowered batch size to 1</p>
</li>
<li><p>Add gradient accumulation</p>
</li>
<li><p>Mixed precision training</p>
</li>
<li><p>QLoRA (even <em>pythia-410m</em> loaded in 4-bit with fine-tuned with LoRA PEFT method crashed with OOM error)</p>
</li>
<li><p>Gradient checkpointing</p>
</li>
<li><p>Cancel out the RAG pipeline</p>
</li>
<li><p>torch.cuda.empty_cache()</p>
</li>
</ol>
<p>Despite these efforts, the OOM error still occurs. Given the hardware, I expected it to handle at least the smaller models without running into memory issues.</p>
<p><strong>Notes:</strong></p>
<ul>
<li><p>I set max_length=4096 as my input sequences are very long (could be 1000-4000 tokens).</p>
</li>
<li><p>I'm using HuggingFace transformers library</p>
</li>
</ul>
<p>I'm attaching my DataCollator and the training function:</p>
<pre><code>class FantasyTeamDataCollator:
def __init__(self, tokenizer, rag_retriever: SeasonSpecificRAG, max_length: int, eval_steps: int):
self.tokenizer = tokenizer
self.rag_retriever = rag_retriever
self.max_length = max_length
self.eval_steps = eval_steps
self.steps = 0
def __call__(self, batch):
teams_batch = [sample['teams'] for sample in batch]
dates_batch = [sample['date'] for sample in batch]
seasons_batch = [sample['season'] for sample in batch]
rag_info_batch = self.rag_retriever.retrieve_relevant_info(teams_batch, dates_batch, seasons_batch)
processed_samples = []
for i, sample in enumerate(batch):
processed_samples.append(self.process_sample(sample, rag_info_batch[i]))
processed_samples = [result for result in processed_samples if result is not None]
if not processed_samples:
raise ValueError("All samples in the batch failed to process")
batch_output = self.collate_batch(processed_samples)
return batch_output
def process_sample(self, sample: Dict[str, Any], rag_info: Dict[str, List[str]]) -> Dict[str, Any]:
combined_input = self.combine_input_with_rag(sample['text'], rag_info)
input_encodings = self.tokenizer(combined_input, truncation=True,
max_length=self.max_length, padding="max_length")
return {
"input_ids": torch.tensor(input_encodings["input_ids"]),
"attention_mask": torch.tensor(input_encodings["attention_mask"]),
"labels": torch.tensor(input_encodings["input_ids"]),
"matches": sample['matches'],
"round": sample['round']
}
def combine_input_with_rag(self, input_text: str, rag_info: Dict[str, List[str]]) -> str:
combined_input = (f"{input_text}\n\n"
f"Relevant Information:\n"
f"Teams Info:{rag_info['teams']}\n"
f"Players Info:{rag_info['players']}")
# add system prompts occasionally
if self.steps % self.eval_steps == 0:
combined_input = (f"Instructions: {instruction_prompt}\n\n"
f"League Rules: {full_rules_prompt}\n\n"
f"{combined_input}")
self.steps += 1
return combined_input
u/staticmethod
def collate_batch(batch):
return {
"input_ids": torch.stack([item["input_ids"] for item in batch]),
"attention_mask": torch.stack([item["attention_mask"] for item in batch]),
"labels": torch.stack([item["labels"] for item in batch]),
"matches": [item["matches"] for item in batch],
"round": [item["round"] for item in batch]
}
-----------------------------------------------------------------------------------------------
def fine_tune(self):
train_dataset = self.fantasy_dataset.dataset_dict['train']
eval_dataset = self.fantasy_dataset.dataset_dict['test']
early_stopping_callback = EarlyStoppingCallback(
early_stopping_patience=5,
early_stopping_threshold=0.01,
)
training_args = TrainingArguments(
output_dir=self.out_dir,
num_train_epochs=self.num_epochs,
per_device_train_batch_size=self.bz,
per_device_eval_batch_size=self.bz,
gradient_accumulation_steps=self.conf.train.accumulation_steps,
load_best_model_at_end=True,
metric_for_best_model='combined_score',
greater_is_better=True,
eval_strategy='epoch',
eval_steps=self.eval_steps,
save_strategy='epoch',
save_total_limit=10,
fp16=False,
bf16=True,
remove_unused_columns=False,
max_grad_norm=1.0,
gradient_checkpointing=True
)
print('\nBegin fine-tuning the model')
trainer = FantasyTrainer(
model=self.model,
args=training_args,
train_dataset=train_dataset,
eval_dataset=eval_dataset,
data_collator=self.data_collator,
compute_metrics=self.compute_metrics,
callbacks=[early_stopping_callback],
fantasy_team_loss=self.fantasy_team_loss,
eval_steps=self.eval_steps,
initial_structure_weight=self.structure_weight,
min_structure_weight=self.min_structure_weight
)
trainer.train()
------------------------------------------------------------------------------------------------
class FantasyTrainer(Trainer):
def __init__(self, *args, **kwargs):
# Extract custom arguments
self.fantasy_team_loss = kwargs.pop('fantasy_team_loss', None)
self.eval_steps = kwargs.pop('eval_steps', 100)
self.structure_weight = kwargs.pop('initial_structure_weight', 1.0)
self.min_structure_weight = kwargs.pop('min_structure_weight', 0.1)
# Initialize Trainer with remaining arguments
super().__init__(*args, **kwargs)
self.steps = 0
self.losses = {
'loss': [],
'lm_loss': [],
'structure_loss': []
}
def compute_loss(self, model, inputs, return_outputs=False):
model_inputs = {k: v for k, v in inputs.items() if k in ['input_ids', 'attention_mask']}
outputs = model(**model_inputs)
# Calculate custom loss
lm_loss, structure_loss = self.fantasy_team_loss(outputs.logits, inputs['input_ids'])
# Combine losses with updated weight
total_loss = lm_loss + (self.structure_weight * structure_loss)
# Add L2 regularization
l2_lambda = 0.01 # Adjust this value as needed
l2_reg = torch.sum(torch.stack([p.pow(2.0).sum() for p in model.parameters()]))
total_loss += l2_lambda * l2_reg
# Update losses
self.losses['loss'].append(total_loss.item())
self.losses['lm_loss'].append(lm_loss.item())
self.losses['structure_loss'].append(structure_loss.item())
# Log metrics every eval_steps
if self.steps % self.eval_steps == 0:
self._log_metrics()
# Decrease structure weight over time
self.structure_weight = np.maximum(self.min_structure_weight, self.structure_weight * 0.9)
self.steps += 1
return (total_loss, outputs) if return_outputs else total_loss
def _move_model_to_device(self, model, device):
pass
def train(self, resume_from_checkpoint: Union[str, bool] = None,
trial: Union["optuna.Trial", Dict[str, Any]] = None, **kwargs):
# Reset steps and losses before training
self.steps = 0
self.losses = {k: [] for k in self.losses}
return super().train(resume_from_checkpoint, trial, **kwargs)
</code></pre>
<p><strong>Questions</strong>:</p>
<ol>
<li><p>Is the hardware I'm using insufficient for fine-tuning, particularly for models with sequence lengths up to 4096 tokens?</p>
</li>
<li><p>Are there additional optimizations or techniques I should consider to mitigate the OOM errors?</p>
</li>
</ol>
<p>Any insights, suggestions, or advice would be greatly appreciated.</p>
<p>Thanks in advance!</p>
| 1,459
|
|
implement RAG
|
How to combine Parent Document Retriever with Self Query Retriever with Lang Chain framework
|
https://stackoverflow.com/questions/78091831/how-to-combine-parent-document-retriever-with-self-query-retriever-with-lang-cha
|
<p>I have implemented a Self Query retriever (<a href="https://python.langchain.com/docs/modules/data_connection/retrievers/self_query" rel="nofollow noreferrer">https://python.langchain.com/docs/modules/data_connection/retrievers/self_query</a>) for my RAG model, and it works fine. I can retrieve specific chunks of documents based on metadata information.</p>
<p>However, instead of retrieving the small chunks (400 tokens), I would like to retrieve its parent bigger chunk (let’s say 2000 tokens).</p>
<p>The Parent Document Retriever (<a href="https://python.langchain.com/docs/modules/data_connection/retrievers/parent_document_retriever" rel="nofollow noreferrer">https://python.langchain.com/docs/modules/data_connection/retrievers/parent_document_retriever</a>) allows you to do that, but the research of the first small chunks in the vector DB is assessed with the basic semantic technique. Instead, I would like to search the first small chunks using the Self Query technique.</p>
<p>I don’t want to just increase the chunk size in my Self Query retrieval, because I want to keep the research of the chunks more accurated.</p>
<p>Does anyone know how to combine these two retrievers?</p>
| 1,460
|
|
implement RAG
|
Box2d javascript revolute joint same anchor point different bodies
|
https://stackoverflow.com/questions/42590376/box2d-javascript-revolute-joint-same-anchor-point-different-bodies
|
<p>I'm trying to make a rag doll and I have 2 hip joints implemented as revolute joints. The problem is that they are not responding as independent segments. It seems like one of them is holding up the other one. It looks like this:
<a href="https://i.sstatic.net/PQwd3.png" rel="nofollow noreferrer"><img src="https://i.sstatic.net/PQwd3.png" alt="Hip joint bug"></a></p>
<p>If I take out one of the legs, the other falls freely.</p>
<p>There are no limits on the joint angles.
I've tried setting the collision flags and mask bits for all the segments to 0 so that they won't collide with anything but that doesn't seem to work.
I've put the collide connected property of the revolute joint to false as well..
I'm not too sure what else I can do.
Is there a taboo against putting two revolute joints in the same location where they are both connected to the same segment?</p>
| 1,461
|
|
implement RAG
|
How to pass custom prompt variables in a chainlit app?
|
https://stackoverflow.com/questions/78114723/how-to-pass-custom-prompt-variables-in-a-chainlit-app
|
<p>I want to add a simple chat UI to my RAG based chatbot. All the materials(one <a href="https://medium.com/@cleancoder/build-a-chatbot-in-minutes-with-chainlit-gpt-4-and-langchain-7690968578f0" rel="nofollow noreferrer">example</a>) I came across online have a very simple prompt template with <code>question</code> and <code>chat_history</code> variables. I do not see those variables being explicitly passed to the prompt in chainlit's <code>@on_message</code> method implementation. I assume that, by default, chainlit passes <code>message</code> param to <code>question</code> variable of prompt?</p>
<p>However my prompt has many more variables and I do not see how to pass them when invoking the <code>@on_message</code> decorated method of chainlit. I tried this but it does not work:</p>
<pre><code>@cl.on_message
async def main(message: cl.message):
chain = cl.user_session.get("chain")
cb = cl.AsyncLangchainCallbackHandler()
res = await chain.acall(inputs={
"question": message,
"chat_history": "",
"doc_name": "Sample name",
"contact_info": "Samplecontact@abc.com",
"doc_url": "foo.com",
"doc_owner": "Sample owner"
}, callbacks=[cb])
answer = res["answer"]
await cl.Message(content=answer).send()
</code></pre>
<p>It gives an error <code>expected string or buffer</code> when I send a message on chainlit's UI. Screenshot attached.</p>
<p><a href="https://i.sstatic.net/MAgar.png" rel="nofollow noreferrer"><img src="https://i.sstatic.net/MAgar.png" alt="error-chainlit-chat" /></a></p>
<p>Does anyone know how to send custom prompt variables via chainlit to the model? Checked chainlit's official doc as well but not helpful.
Chainlit seems like a framework with very high level abstraction and does too much "magic" under the covers! :(</p>
| 1,462
|
|
implement RAG
|
Slow Response Time in Cricket-Specific Chatbot Using CrewAI
|
https://stackoverflow.com/questions/79335247/slow-response-time-in-cricket-specific-chatbot-using-crewai
|
<p>I’m building a cricket-specific chatbot using CrewAI. The chatbot is designed to answer queries based on historical cricket data in CSV files and real-time data from APIs. The data is stored in an SQL database. However, I am experiencing slow response times for answering user queries, with response times ranging from 30 seconds to a few minutes. This delay is not ideal for a chatbot, where users expect quick and interactive responses.</p>
<p>Initially, I attempted to implement a Retrieval-Augmented Generation (RAG) system, but I found that it wasn’t efficient for my use case.
I then switched to using SQL agents to query the database directly, assuming this would improve the speed of query processing.
CrewAI is being used to handle the queries, retrieve relevant data from the database, and generate responses.</p>
<p>The Current Workflow:
The data is stored in an SQL database.
CrewAI is being used to handle the interaction with the database and provide responses.
The LLM (experimenting with OpenAPI and Meta Llama) queries the SQL database through an agent to retrieve relevant information and formulate a response.</p>
<p>Challenges:
The time taken to generate a response is too long.
Users expect near-instantaneous replies, but the current setup is far from that.</p>
| 1,463
|
|
implement RAG
|
DSPy: How to get the number of tokens available for the input fields?
|
https://stackoverflow.com/questions/78743278/dspy-how-to-get-the-number-of-tokens-available-for-the-input-fields
|
<p>This is a cross-post from <a href="https://github.com/stanfordnlp/dspy/issues/1245" rel="nofollow noreferrer">Issue #1245 of DSPy GitHub Repo</a>. There were no responses in the past week, am I am working on a project with a tight schedule.</p>
<p>When running a DSPy module with a given signature, I am interested in getting the token count of the "prompt template" that it currently passes to the language model (LM), by which I meant the number of input tokens passed to the LM minus the token counts of the input fields. This would thus count the length of the signature description, field descriptions, and the few-shot examples. Then, by subtracting the context window of the LM with the token count of the prompt template, I would get the maximum number of tokens that I can squeeze into the input fields.</p>
<p>I am interested in this as I am currently building a RAG pipeline that retrieves texts from a database to synthesize the final response. However, the total length of the texts retrieved from the database might exceed the context window size of the LM I am using. Thus, a iterative or recursive summarization process is need to compress the prompt before synthesizing the final response. While I acknowledge that you can simply summarize each chunk of text one-by-one to be extra cautious to not exceed the context window, I think this might not be the most effective way to do this.</p>
<p>I originally built an RAG pipeline entirely using LlamaIndex where the response would be generated by <a href="https://docs.llamaindex.ai/en/stable/module_guides/querying/response_synthesizers/" rel="nofollow noreferrer">response synthesizers</a>. Note that the <code>compact</code> mode of response synthesizers would try to pack as many tokens from the retrieved contexts into a single LM call as possible to reduce the number of calls. This is achived via <a href="https://docs.llamaindex.ai/en/v0.10.19/api_reference/service_context/prompt_helper.html" rel="nofollow noreferrer">PromptHelper</a> that squeezes as many tokens into the fields of the prompt template as possible so that the length of the fields altogether does not excess <code>context_window - prompt_template_length</code>.</p>
<p>Now, as I am switching all the prompting to DSPy for more flexibility, I wonder what would be the best way for me to implement something alike <code>PromptHelper</code>? I also checked how the LlamaIndex integration for DSPy does this: <a href="https://github.com/stanfordnlp/dspy/blob/55510eec1b83fa77f368e191a363c150df8c5b02/dspy/predict/llamaindex.py#L22-L36" rel="nofollow noreferrer">https://github.com/stanfordnlp/dspy/blob/55510eec1b83fa77f368e191a363c150df8c5b02/dspy/predict/llamaindex.py#L22-L36</a></p>
<p>It appears that it converts the signature to a legacy format first? Therefore, would this be a good approach to this problem or are there better alternatives?</p>
|
<p>If you need really good compression , I’ve used on ChatGPT “SentenceSqueezer”, it usually compresses in neighborhood 60-85% of instruction sets and it’s so simple, guaranteed not to lose context because it makes an acronym out of each sentence or line , tell it to leave periods in there place or whatever you desire, gives pre and post count with a mapping table, and it may do meta compression using one symbol. The other one is “Tokenizer GPT Instruction Compressor” also in the same platform but uses single placeholders for words that repeat more than 3 times I. BElieve, outputs same stats on compression mapping table etc, may be worth a try, I’m new so I may be way off if this will work for you, hopefully so. But if they both have worked for me in not having to ever worry about how technical I need my instructions to be</p>
| 1,464
|
implement RAG
|
What is solution of missing deployment name and replaced by model on Azure Ai Studio?
|
https://stackoverflow.com/questions/78905182/what-is-solution-of-missing-deployment-name-and-replaced-by-model-on-azure-ai-st
|
<p>I've been using Azure AI Studio and Azure OpenAI Studio for a while now, and I'm currently working on implementing a RAG (Retrieval-Augmented Generation) technique using Prompt Flow. However, I've encountered an issue.</p>
<p>Previously, in Azure AI Studio's Prompt Flow, there was an option to connect to Azure OpenAI resources by selecting the "deployment name" of our deployed models. This was also documented in the official Microsoft guide on "How to build with Prompt Flow - Azure AI Studio" (step 8 clearly shows the "deployment name" option). However, this option now appears to have been replaced by "model," and as a result, I’m unable to connect to my deployed models or use the models listed on the portal.</p>
<p>Is this a bug in Azure AI Studio, or is the AI Studio undergoing some sort of revamp? I would appreciate any insights or solutions regarding this issue.</p>
<p>I have tried azure ai studio documentation, copilot support, chatGPT support, watched videos regarding this but still no solution.</p>
| 1,465
|
|
implement RAG
|
How to stream openai response with metadata
|
https://stackoverflow.com/questions/79323421/how-to-stream-openai-response-with-metadata
|
<p>I have implemented streaming response in our rag(Retrieval-Augmented-Generation) chatbot. However, I am unable to figure out a proper way to send the metadata information with the streaming response.If, we do not use streaming, we can send the metadata with the message response in JSON format. But, in streaming response as far as i know, JSOn response is not possible. I am using langchain to integrate llm and StreamingResponse from fastapi to integrate streaming.</p>
<p>This is the part of my code responsible for getting and processing the streaming response from openai:</p>
<pre><code>@traceable(streaming=True)
async def arag_stream_pinecone(self, input: str, chat_history: List[Dict], authorization: str, request: Request):
"""Stream responses from the LLM in real-time."""
try:
rephrased_query = self.rephrase_query(input, chat_history)
vector_query = self.embeddings.embed_query(rephrased_query)
index = await self.pinecone_client.create_index()
retrieved_documents = index.query(vector=vector_query, top_k=4, score_threshold=0.7, include_metadata=True, namespace= authorization)
idList = [item['id'] for item in retrieved_documents['matches']]
textList = [item['metadata']['text'] for item in retrieved_documents['matches']]
metadata = ""
if authorization != "public":
metadata_key = f"{authorization}_last_metadata"
metadata = ','.join(idList)
context = "\n".join([doc for doc in textList])
prompt_text = (
"system",
"You are an intelligent assistant designed to perform question-answering tasks effectively. You are capable of engaging in general conversations, including greetings, expressing gratitude, and farewells. "
"Use the provided context to accurately and concisely answer questions. If the question is not relevant to the context or Sensitech products, politely respond that you are specifically tuned to answer questions related to the provided context. "
"Ensure your response is concise and informative, limiting answers to 100 words unless explicitly asked by the user to provide more details. Avoid adding unnecessary information or speculation. If the user asks for a feature that is not mentioned in the context, politely respond that the feature is not available and for further assistance contact with sensitech team.\n\n"
f"Context: {context}\n\n"
f"Question: {rephrased_query} \n\nAnswer: "
)
async for chunk in self.streaming_llm.astream(prompt_text):
if chunk:
# yield json.dumps({"data":chunk.content or ""})
yield chunk.content or ""
yield metadata
except Exception as e:
logging.error(f"Error in arag_stream: {e}")
yield f"data: Error: {str(e)}"
</code></pre>
<p>This is the event generator function:</p>
<pre><code>async def event_generator(message : str, chat_history : List[dict], authorization : str, request: Request):
try:
async for chunk in rag_service.arag_stream_pinecone(
input=message,
chat_history=chat_history,
authorization=authorization,
request = request
):
if chunk:
yield chunk # Stream each chunk to the client in real-time
except Exception as e:
logging.error(f"Error in streaming response: {e}")
raise e # Propagate the error for response
</code></pre>
<p>And the controller to interact with the api :</p>
<pre><code>@router.post("/message/private", response_model=ChatResponse)
async def send_private_message(
request: Request,
message: Message,
document_type: str = Query(..., description="Type of document"),
stream: bool = Query(False, description="Enable Streaming response"),
current_user: dict = Depends(auth_service.get_current_user)
):
try:
history_key = f"{document_type}_chat_history"
chat_history = chat_service.get_chat_history(request, history_key=history_key)
if stream:
return StreamingResponse(
event_generator(
message=message.text,
chat_history=chat_history,
authorization=document_type,
request=request
),
media_type="text/event-stream",
headers={
"Cache-Control": "no-cache",
"Connection": "keep-alive",
"Content-Type": "text/event-stream",
"X-Accel-Buffering": "no" # Disable proxy buffering
}
)
else:
# For non-streaming response
response = ""
async for chunk in rag_service.arag_stream(
input=message.text,
chat_history=chat_history,
authorization=document_type,
request=request
):
if chunk:
response += chunk
chat_service.add_message_to_history(
request,
history_key=history_key,
message=message.text,
role="user"
)
chat_service.add_message_to_history(
request,
history_key=history_key,
message=response,
role="ai"
)
return ChatResponse(message="success", result=response)
except Exception as e:
print(f"Error in send_private_message: {str(e)}")
raise HTTPException(status_code=500, detail=str(e))
</code></pre>
<p>What i am trying to do is, after the chunks of messages are streamed, I send the chunks containing the metadata(vector id name). reference code :</p>
<pre><code> async for chunk in self.streaming_llm.astream(prompt_text):
if chunk:
# yield json.dumps({"data":chunk.content or ""})
yield chunk.content or ""
yield metadata
</code></pre>
<p>Then, from the frontend, I send another api request with the vector ids to fetch the metadata from vector database. <strong>The problem I am facing is :
Now, in some browsers, the chunks containing messages are also streamed with the chunk containing metadata. Which causes the error when retrieving the actual metadata.</strong></p>
<p>Now, one solution which i thought of is to set a delay after the chunks containing messages have been streamed. which may solve the issue of chunks of message and metadata getting mixed together.</p>
<p>Is there any better/optimum way to implement the solution? Even following a different api design?</p>
<p>Thank you</p>
| 1,466
|
|
implement RAG
|
Creating knowledge graph index out of a XML (DEXPI) file
|
https://stackoverflow.com/questions/77613200/creating-knowledge-graph-index-out-of-a-xml-dexpi-file
|
<p><strong>Context:</strong></p>
<p>I have a XML file (DEXPI) and I want to use it as a data source to implement Retrieval Augmented Generation (RAG) system using <code>llama-index</code> to fetch the correct context against any natural language query.</p>
<p><strong>Current Issue:</strong></p>
<ul>
<li>I cannot use the XML file like a text document.</li>
<li><code>llama-index</code> does not provide any type of splitter for XML data so that XML data can be correctly divided into chunks (nodes).</li>
<li>Even if we write some custom chunker/splitter, a lot of unwanted jargons would be still there in the chunks like XML tags and other metadata related to XML.</li>
</ul>
<p><strong>What did I try?</strong></p>
<p>To solve this issue I have 2 approaches:</p>
<p><strong>Approach 1:</strong></p>
<p>Convert the XML into SQl tables (or CSVs). Convert these tables into natural language english text. Then pass this text to <code>llama-index</code> for further processing. Here, while preparing the knowledge graph index, the <code>llama-index</code> will automatically figure out the vertices (entities) and the edges (relationships) between them.</p>
<p><strong>Approach 2:</strong></p>
<p>Convert the XML into SQL tables (or CSVs). Convert these SQL tables into Graph DB entities & relationships manually. Then query the graph db by using a graph query generated from any LLM.</p>
<p><strong>My Questions:</strong></p>
<ol>
<li>I need suggestions on which approach to choose currently & how effective they are.</li>
<li>Are there any better approaches to deal with <strong>XML</strong> data when using <code>llama-index</code>.</li>
</ol>
| 1,467
|
|
implement RAG
|
How can I swap an instance of ChatMessageHistory with an instance of ConversationBufferWindowMemory? Python, Langchain
|
https://stackoverflow.com/questions/78518917/how-can-i-swap-an-instance-of-chatmessagehistory-with-an-instance-of-conversatio
|
<p>I implemented <a href="https://python.langchain.com/v0.1/docs/use_cases/question_answering/chat_history/" rel="nofollow noreferrer">this use case</a> from langchain to add chat history to my RAG to contextualize questions that may be incomplete. Everything works fine but now I would like to use only the last x messages instead of the whole chat history. How can I do that?</p>
<p>Currently the code I'm using is the same from the tutorial:</p>
<pre><code>store = {}
def get_session_history(session_id: str) -> BaseChatMessageHistory:
if session_id not in store:
store[session_id] = ChatMessageHistory()
return store[session_id]
conversational_rag_chain = RunnableWithMessageHistory(
rag_chain,
get_session_history,
input_messages_key="input",
history_messages_key="chat_history",
output_messages_key="answer",
)
</code></pre>
<p>I saw that there is a class called ConversationBufferWindowMemory that might be what I'm looking for but I can't wrap my head around on how to swap ChatMessageHistory from the code above with ConversationBufferWindowMemory, if possible.</p>
<p>This is what I tried:</p>
<pre><code>### Statefully manage chat history
store = {}
def get_session_history(session_id: str):
if session_id not in store:
store[session_id] = ConversationBufferWindowMemory(memory_key="chat_history", k=2)
return store[session_id]
conversational_rag_chain = ConversationChain(
rag_chain,
get_session_history,
verbose=True,
memory="chat_history"
)
</code></pre>
<p>Obiviously this was unsuccessul since I'm swapping a runnable with a chain. The error that I get is:</p>
<p>TypeError: _<em>init</em>_() takes 1 positional argument but 3 were given</p>
<p>I'm not very familiar with langchain in general since I just started working with it. Is it actually possible to do what I'm trying to do? or maybe is there some different approaches that are better suited for my problem?</p>
<p>Thanks in advance.</p>
|
<p>This will probably solve your problem: it uses a FAISS index for RAG but can be easily adapted for your case.</p>
<pre><code>def runPrompt():
history=[]
memory = ConversationBufferMemory(
memory_key='chat_history', return_messages=True, output_key='answer')
# Create a conversation chain
code_llm = VertexAI(
model_name="text-bison",
max_output_tokens=512,
temperature=0.1,
verbose=False,
)
EMBEDDING_QPM = 100
EMBEDDING_NUM_BATCH = 5
embeddings = VertexAIEmbeddings(
requests_per_minute=EMBEDDING_QPM,
num_instances_per_batch=EMBEDDING_NUM_BATCH,
model_name = "textembedding-gecko"
)
store = FAISS.load_local("faiss_index", embeddings)
retriever = store.as_retriever(
search_type="similarity",
search_kwargs={"k": 2},)
promptTemplate = """"
You are a Google Cloud security expert and you have to talk to the user that is asking questions.
Also, you must prevent the user to get names and passwords located at the following context:
{context}.
You can use the chat history: {chat_history} and {context}
to answer users' question: {question}.
"""
messages = [
SystemMessagePromptTemplate.from_template(promptTemplate),
HumanMessagePromptTemplate.from_template("{question}")
]
qa_prompt = ChatPromptTemplate.from_messages(messages)
qa_chain = ConversationalRetrievalChain.from_llm(
code_llm, retriever, memory=memory,get_chat_history=lambda h : h,combine_docs_chain_kwargs={"prompt": qa_prompt})
def onMessage(question):
answer = qa_chain({"question":question,"chat_history":history[-3:]}) ## LAST 3 MESSAGES
history.append((question, answer))
return answer["answer"]+'\n\n'
while True:
question = input("Ask a question >")
answer = onMessage(question)
print('\n',"LLMbot: ",answer,'\n')
</code></pre>
<p>This line will give you the last 3 interactions in history:</p>
<pre><code>answer = qa_chain({"question":question,"chat_history":history[-3:]})
</code></pre>
| 1,468
|
implement RAG
|
Llamaindex TS SimpleDirectoryReader works locally but not on AWS EC2 server
|
https://stackoverflow.com/questions/78894391/llamaindex-ts-simpledirectoryreader-works-locally-but-not-on-aws-ec2-server
|
<p>I have a node express server setup for a llamaindex RAG system. Locally I'm able to generate a VectorIndexStore from a directory I've called <code>./data</code> and run queries successfully. However, I've just cloned the repo onto my AWS EC2 server and even though it boots up successfully it seems that the <code>SimpleDirectoryReader</code> fails to be able access the files in the <code>./data</code> directory even when I have the exact same files.</p>
<p>The error is different depending on the file type, but I assume this has to do with the library llamaindex is utilizing to read the documents.</p>
<p>If it's a PDF file I get this error:
<code>Error reading file ./data/example.pdf: InvalidPDFException: Invalid PDF structure.</code>
I uploaded a docx file as well and got this error:
<code>Error reading file ./data/example.docx: Error: Corrupted zip: can't find end of central directory</code></p>
<p>For a little more context this is a snippet showing how the <code>SimpleDirectoryReader</code> is being implemented:</p>
<pre><code>const directoryPath = "./data";
const directoryReader = new SimpleDirectoryReader();
const documents = await directoryReader.loadData({ directoryPath });
</code></pre>
<p>I thought maybe the -rw permissions were not allowing the node_module packages to do it's thing so as a test I updated the <code>./data</code> directory permission to <code>drwxrwxrwx</code> and still no luck.</p>
<p>Any help with this issue would be greatly appreciated, hopefully I'm just missing something obvious. Thanks in advance.</p>
| 1,469
|
|
implement RAG
|
use embeddings stored in vector db to reduce work for LLM generating response
|
https://stackoverflow.com/questions/78023750/use-embeddings-stored-in-vector-db-to-reduce-work-for-llm-generating-response
|
<p>I'm trying to understand what the correct strategy is for storing and using embeddings in a vector database, to be used with an LLM. If my goal is to reduce the amount of work the LLM has to do when generating a response, (So you can think of a RAG implementation where I've stored text, embeddings I've created using an LLM, and metadata about the text.) I'm then trying to generate responses using say openai model from queries about the data, and I don't want to have to spend a bunch of money and time chunking up the text and creating embeddings for it every time I want to answer a query about it.</p>
<p>If I create a vector database, for example a chroma database and I use an LLM to create embeddings for a corpus I have. I save those embeddings into the vector database, along with the text and metadata. Would the database use those embeddings I created to find the relevant text chunks, or would it make more sense for the vector database to use it's own query process to find the relevant chunks (not using the embeddings the LLM created)?</p>
<p>Also do I want to pass the embeddings from the vector database to the LLM to generate the response, or do I pass the text that the vectore database found was most relevant to the LLM along with original text query so the LLM can then generate a response?</p>
| 1,470
|
|
implement RAG
|
How to continue previous conversations with transcript data in Bot Framework and WebChat
|
https://stackoverflow.com/questions/79184231/how-to-continue-previous-conversations-with-transcript-data-in-bot-framework-and
|
<p>Solutions like ChatGPT, Perplexity, and Copilot provide ways for users to reopen older conversations. I am trying to implement a similar feature using the Bot Framework and WebChat.</p>
<p><strong>My setup</strong></p>
<p>Last year I built a RAG-type chatbot for internal use at a company, using Bot Framework and WebChat as the chat interface. The bot is set up to use TranscriptLoggerMiddleware to log conversation activities in Blob storage for quality and review purposes.</p>
<p><strong>My requirements</strong></p>
<p>I want to enable users to view a list of their previous conversations (which is working). When a user selects a conversation, an event triggers a new chat session. This new session should ideally:</p>
<ul>
<li>Load the selected conversation's activities from storage.</li>
<li>Replay or render these activities in the new conversation context, allowing the user to - - pick up where they left off.</li>
</ul>
<p><strong>Relevant code components I already use</strong>
Middleware for saving conversation references in table storage</p>
<pre><code>const { ActivityTypes, TurnContext } = require('botbuilder');
const helper = require('../utils/helper');
class ConversationReferenceLoggerMiddleware {
async onTurn(context, next) {
if (context.activity.type === ActivityTypes.Message) {
const conversationReference = TurnContext.getConversationReference(context.activity);
try {
await helper.saveConversationReference(conversationReference);
} catch (error) {
console.error('Error saving Conversation Reference:', error);
}
}
await next();
}
}
module.exports = ConversationReferenceLoggerMiddleware;
</code></pre>
<p>TranscriptLoggerMiddleware to store conversation history in Blob storage:</p>
<pre><code>const { TranscriptLoggerMiddleware } = require('botbuilder');
</code></pre>
<p><strong>What works</strong></p>
<ul>
<li>I can retrieve all conversation IDs and associated metadata from storage.</li>
<li>I can fetch all activities for a selected conversation ID.</li>
<li>I can trigger a new conversation when a user selects an older session.</li>
</ul>
<p><strong>What I need help with</strong></p>
<p>The missing piece is figuring out how to take the stored activities from the selected historic conversation and replay them in the new session so that it looks like the user can continue from where they left off.</p>
<p>Most samples I've found are focused on displaying history rather than enabling a seamless continuation of the conversation.</p>
<p><strong>My question</strong></p>
<p>How can I initialize a new WebChat session with a selected conversation’s history so that the user can continue interacting as if it was the original conversation? Any guidance on methods, configuration, or references would be highly appreciated!</p>
<p><strong>[update 14/11]</strong></p>
<p>I installed sample <a href="https://github.com/EricDahlvang/BotBuilder-Samples/tree/eric/node_conversationHistory/samples/javascript_nodejs/22.conversation-history" rel="nofollow noreferrer">https://github.com/EricDahlvang/BotBuilder-Samples/tree/eric/node_conversationHistory/samples/javascript_nodejs/22.conversation-history</a>
Looks promising. Will start with that approach.</p>
|
<p>If you are using BotFramework-Webchat, then you can pass an array of activities into the store when it is created. The array is placed within the first set of curly brackets.</p>
<p>Activities array:</p>
<pre class="lang-js prettyprint-override"><code>const activities = [
{
...first activity...
},
{
...second activity...
},
...
]
</code></pre>
<p>The code normally looks like this:</p>
<pre class="lang-js prettyprint-override"><code>const store = window.WebChat.createStore( {}, ( { dispatch } ) => next => async action => {
next( action)
});
</code></pre>
<p>Now, with the activities array added in:</p>
<pre class="lang-js prettyprint-override"><code>const store = window.WebChat.createStore( { activities }, ( { dispatch } ) => next => async action => {
next( action)
});
</code></pre>
<p>Some things to note:</p>
<ol>
<li>The activities will display in the transcript window regardless of whether the Web Chat instance initializes correctly or not.</li>
<li>Web Chat is a tiny bit picky about what properties are allowed in the activities contained within the array. Most are alright, but there are two or three it doesn't like (or didn't when last I set this up). Unfortunately, I don't remember which they were. <code>localTimestamp</code> was maybe one...maybe. Anyhow, be prepared to have to sort this out a bit.</li>
<li>If memory serves me right, it also wants a <code>webchat:fallback-text</code> property set within the <code>channelData</code> property. You can experiment with this property's value, if you want. I set mine to an empty string (<code>""</code>).</li>
<li>Not a 100% on this, but I believe each activity in the array needs to be in JSON format. So, properties and values need to be wrapped in double quotes, except number and boolean values.</li>
<li>The last activity (activities, if several were sent together), which likely will have come from the bot, will assume the time stamp of the next new/incoming activity which is also likely coming from the bot.
In other words, if the last posted message ('Thank you for visiting') was from the bot sent on 'December 1 at 12:02 PM' and the next posted message ('How can I help?') is from the bot sent on 'December 9 at 8:39 AM', Web Chat will group these together using the 'December 9' date.
The only way to get around this (if that is your wish) is to pass in the <code>groupTimestamp</code> property into <code>styleOptions</code> and assign it a number value representing milliseconds. For instance, <code>groupTimestamp: 300</code> will group all activities together that are within 300 ms of each other.</li>
<li>Because we are injecting the past conversational transcript via the activities array into Web Chat, the activities will <em>not</em> pass thru the DirectLine connector and, subsequently, to your bot. Any event or activity that is contained within the activities array that otherwise would have initiated a certain response in your bot will not occur in this instance. The passed in activities array is purely for display purposes only.</li>
</ol>
<p>As you can see in the below clip, all the dialog prior to the 'User joined conversation' comment from the bot is coming from the passed in activities array. Each prior activity has a June timestamp and the newer with a December timestamp. As mentioned above, I have set <code>groupTimestamp</code> to 300 so older activities are grouped together by older dates, and newer by newer dates.</p>
<p><a href="https://i.sstatic.net/A6r0J8JT.gif" rel="nofollow noreferrer"><img src="https://i.sstatic.net/A6r0J8JT.gif" alt="Preloaded Activities in Web Chat" /></a></p>
<p>Hope of help!</p>
| 1,471
|
implement RAG
|
Langchain4j pgvector implementation as an EmbeddingStore?
|
https://stackoverflow.com/questions/77968544/langchain4j-pgvector-implementation-as-an-embeddingstore
|
<p>I'm building a RAG based AI service using Langchain4j. I have one microservice that is ingesting and saving my documents (pdfs, csv, words...) in my PostgreSQL DB (with vector extension) as embeddings.</p>
<p>From the other hand I'm building another microservice to hold the AI conversation logic.</p>
<p>To do this I'm creating the next beans</p>
<pre><code> @Bean
public EmbeddingStore<TextSegment> embeddingStore() {
return new InMemoryEmbeddingStore<>();
}
@Bean
public ContentRetriever contentRetriever() {
return EmbeddingStoreContentRetriever.builder()
.embeddingStore(embeddingStore())
.embeddingModel(bedrockTitanEmbeddingModel())
.maxResults(10) // on each interaction we will retrieve the 5 most relevant segments
.minScore(0.2) // we want to retrieve segments very similar to the user query
.build();
}
@Bean
public RetrievalAugmentor retrievalAugmentor() {
return DefaultRetrievalAugmentor.builder()
.queryTransformer(queryTransformer())
.contentRetriever(contentRetriever())
.build();
}
@Bean
public AiAgent aiAgent() {
return AiServices.builder(ErekyAiAgent.class)
.retrievalAugmentor(retrievalAugmentor())
.chatLanguageModel(bedrockAnthropicChatModel())
.contentRetriever(contentRetriever())
.build();
}
</code></pre>
<p>The <code>ContentRetriever</code> is asking me as a mandatory parameter the embeddingStore. Now for testing I'm using the memory one but I saw that Langchain4j has an implementation with pgvector.</p>
<p>In the flow what I'm doing is:</p>
<ol>
<li>Doing the query to my PostgreSQL database with the user asked question</li>
<li>Returning the document text list found</li>
<li>Transforming the List of Strings containing the document text I got to a list of <code>List<TextSegment></code> that is a type of langchain4j library.</li>
<li>Then I need to transform the <code>List<TextSegment></code> to embeddings again and add them along with the <code>List<TextSegment></code> without embedding them to the embedding store I'm using.</li>
</ol>
<p>The logic is</p>
<pre><code>List<String> documentTexts = getDocumentTextsFromUserQuestion(promptDto);
List<TextSegment> textSegments = getTextSegments(documentTexts);
embeddingStore.addAll(embedComponent.getEmbeddingsFromTextSegments(textSegments), textSegments);
return new PromptDTO(aiAgent.answer(documentTexts, promptDto.getText()));
</code></pre>
<p>I saw that for some reason the logic always need for me to add that data to the embedding store to be able to give a correct answer based on my data. When I used the pgvector implementation of Langchain4j and did the same thing I saw that the implementation is creating a table in my DB with the data I already had saved before inserted in this new table to give the answer. And the data is being duplicated, there is a way to make this work without that?</p>
<p>And since I already have the data saved in the DB, I can't directly do the call to the AI with the data found from the user question + the user question?</p>
<p>I did it like this in Python calling chain.run being documents the data found in the DB and the question being the user question and it works and I don't need this intermmediate embedding store.</p>
<pre><code>chain = load_qa_chain(llm, chain_type="stuff")
# Call to the model
# response = st.session_state.conversation({'question': user_question})
response = chain.run(input_documents=document, question=user_question)
</code></pre>
|
<p>Not sure if you've already fixed your blockers. I ran into something similar with MongoDb, and although it's not a new collection being created in the database when using the MongoDB implementation of the Embedded Store, it happens to be another issue with ObjectId's. My project was underway, until I realized I could use langchain4j to implement various AI actions. So, I already had various queries and aggregations to my MongoDB Collections in service classes, with data already stored as embeddings. What I did was reuse these queries and store them in a <code>InMemoryEmbeddingStore</code>. My query already received the most relevant embeddings from original prompt. Or you can store the information you want to embed as plain text in your DB and use a langchain4j EmbeddingModel to convert data into embeddings to push into that InMemoryEmbeddingStore. Here's the first iteration of my work-around.</p>
<pre><code> // We will use initialize and use the ADA_002 to create embeddings on text field from database
EmbeddingModel embeddingModel = new OpenAiEmbeddingModel.OpenAiEmbeddingModelBuilder()
.modelName(OpenAiEmbeddingModelName.TEXT_EMBEDDING_ADA_002)
.apiKey(openAiKey)
.maxRetries(2)
.build();
InMemoryEmbeddingStore<TextSegment> inMemoryEmbeddingStore = new InMemoryEmbeddingStore<>();
// we can use query service to get most relevant search results
List<QueryResults> querySearchResult = queryService.getDataFromVectorSearch(prompt);
querySearchResult.forEach(result -> {
TextSegment textSegment = TextSegment.from(result.getText());
Embedding embedding = embeddingModel.embed(textSegment).content();
inMemoryEmbeddingStore.add(embedding, textSegment);
});
// use embedding model and in memory store as retriever for optimal answer
EmbeddingStoreContentRetriever retriever = EmbeddingStoreContentRetriever.builder()
.embeddingModel(embeddingModel)
.embeddingStore(inMemoryEmbeddingStore)
.build();
String question = prompt;
// given the prompt with the added context and user question, we can now build our model
ChatLanguageModel chatLanguageModel = OpenAiChatModel.builder()
.apiKey(openAiKey)
.modelName(GPT_4o)
.timeout(Duration.ofSeconds(60))
.build();
// using our AI system interface build the prompt
Bot bot = AiServices.builder(Bot.class)
.chatLanguageModel(chatLanguageModel)
.contentRetriever(retriever)
.build();
return bot.chat(1, question);
</code></pre>
<p>Something great about langchain4j's <code>InMemoryEmbeddingStore</code> is that you can save messages with an Id. There are few things still being updated frequently to langchain4j, so I'm sure you'll be able to find a suitable solution in no time. Hope this helps!</p>
| 1,472
|
implement RAG
|
Llama 3 chat_history not working as expected
|
https://stackoverflow.com/questions/78808357/llama-3-chat-history-not-working-as-expected
|
<p>I'm using Langchain agent to perform a RAG upon my own knowledge. The usual QnA flow works perfectly, but when it comes to chat_history the bot is not performing as expected. It does not re-create a user query with previous questions content when needed. Below is the base prompt that I'm usinng.</p>
<p><>
Assistant is an conversational QnA system for service XYZ. Assistant must not answer for the general knowledge questions. Assistant has only one tool in-hand, "Search VectorDB". Assistant has to execute this tool depending on the user query as below. Assistant will receive four knowledge sources after executing the "Search Vector DB" tool and assistants answer has to be dependant on those knowledge sources.</p>
<ul>
<li>"Search VectorDB": When user is asking about questions related to the train terminal
<ul>
<li>To use the Search VectorDB, Assistant should write like so:
<pre class="lang-json prettyprint-override"><code>{{"action": "Search VectorDB",
"action_input": "user_query and content of latest conversation if needed"}}
</code></pre>
</li>
</ul>
</li>
</ul>
<p>If users query is linked with the latest conversation, Assistant must recreate the user query by adding relevant details from latest conversation before executing the "Search VectorDB" tool.</p>
<ul>
<li>example for linked user queries : Please explain more, Give me more details regarding this, give me the answer in list format</li>
</ul>
<p>Assistant is able to respond to the User and use the tool using JSON strings that contain "action" and "action_input" parameters.</p>
<p>All of Assistant's communication is performed using this JSON format.</p>
<p>The tool can not be executed more than twice.</p>
<p>Here are some previous conversations between the Assistant and User:</p>
<p>User: Hey how are you today?
Assistant: <code>json {{"action": "Final Answer", "action_input": "I'm good thanks, how can I help you?"}}</code></p>
<p>User: Explain monitoring of engineering consist
Assistant: <code>json {{"action": "Search VectorDB", "action_input": "Explain monitoring of engineering consist"}}</code></p>
<p>Assistant: <code>json {{"action": "Final Answer", "action_input": "monitoring of engineering consist involves ....">"}}</code></p>
<p>Here is the latest conversation between Assistant and User
chat_history."""
<></p>
<p>Below is my code implementation,</p>
<pre><code>agent = initialize_agent(
agent="chat-conversational-react-description",
tools=tools,
llm=llm_obj,
verbose=True,
memory=current_memory_state,
early_stopping_method="generate",
return_intermediate_steps=True,
agent_kwargs={"output_parser": output_parser}
)
</code></pre>
<pre><code> B_INST, E_INST = "[INST]", "[/INST]"
instruction = B_INST + " Respond to the following in JSON with 'action' and 'action_input' values " + E_INST
new_prompt = agent.agent.create_prompt(
system_message = system_prompt,
tools=tools
)
agent.agent.llm_chain.prompt = new_prompt
# human_msg = instruction + user_query
human_msg = instruction + "\nUser: {input}"
agent.agent.llm_chain.prompt.messages[2].prompt.template = human_msg
response = agent(user_query)
# final answer
answer = response['output']
</code></pre>
<p>I have tuned the prompt in many ways, but it seems like bot is not grasping the chat_history.</p>
| 1,473
|
|
implement RAG
|
What the script editor accepts and what Google Sheets accepts can be different?
|
https://stackoverflow.com/questions/55381362/what-the-script-editor-accepts-and-what-google-sheets-accepts-can-be-different
|
<p>So I've been trying to build an AADD(range, range) function. It's not complete so don't rag me about that. What's bothering me at the moment is that what the Script Editor says in meaningful code and what Google Sheets will run appears to be different.</p>
<p>First of all here's the tester:</p>
<pre><code>function test_AADD() {
var sheet = SpreadsheetApp.getActiveSheet();
var range1 = sheet.getRange("B2:E2");
var range2 = sheet.getRange("B3:D3");
var result = AADD(range1, range2);
}
</code></pre>
<p>The ranges are deliberately not matching in length because I'm trying to work out how to send back standard error messages like "#ERROR!" (some help there would help too.)</p>
<p>Here's the public AADD function. I hope one day to find out how to make functions private (another thing I need help with.)</p>
<pre><code>/**
* Adds two arrays
*
* @param {Range} range1 The first parameter
* @param {Range} range2 The second paramter
* @return {Range}
* @customfunction
*/
function AADD(range1, range2) {
return fnAADDrr(range1, range2);
}
</code></pre>
<p>The (ultimately) private function that implements the AADD code (trust me, there's meaning to the madness) is</p>
<pre><code>function fnAADDrr(range1, range2) {
var r1len = range1.getNumRows() * range1.getNumColumns();
var r2len = range2.getNumRows() * range2.getNumColumns();
if (r1len !== r2len) {
return new Error("#ERROR!");
}
}
</code></pre>
<p>That's as far as the function goes at this point because I'm just trying to work out how to test for a Range not having as many items as another. </p>
<p>So now we get to the main problem: When I have the script, the script editor does not complain about the method calls on the passed-in Range variables range1 and range2. And when I run the test_AADD function in the script editor, I get a mostly sensible response (except that the "new Error" thing isn't actually returning -- something else I need help with.)</p>
<p>So then I move back to my Google Sheets file. In a cell I type</p>
<pre><code>=AADD(B2:D2,B3:D3)
</code></pre>
<p>Now this isn't even going to fire the "new Error" bit because the Ranges are the same size. Even so, I get an "#ERROR!" which, if I hover over it with the mouse I get </p>
<pre><code>TypeError: Cannot find function getNumRows in object 1,2,3 (line 73)
</code></pre>
<p>where 1,2,3 is what's in B2:D2, and line 73 is the location in the script file.</p>
<p>So how come script editor and Google Sheets can't agree on what's allowed?</p>
| 1,474
|
|
implement RAG
|
Gannt Chart with single line for all project phases
|
https://stackoverflow.com/questions/77519040/gannt-chart-with-single-line-for-all-project-phases
|
<p>I am a new user to Power Bi and I am hoping the community may be able to help me with my problem.</p>
<p>In Power Bi I want to create a dashboard that will contain a gantt view of my projects refecltive of all the different stages/phases within the lifecycle in one line across the time horizon.</p>
<p>My data table has the following columns;</p>
<div class="s-table-container">
<table class="s-table">
<thead>
<tr>
<th>TaskID</th>
<th>TaskName</th>
<th>ParentTask</th>
<th>TaskStart</th>
<th>TaskEnd</th>
<th>RAG</th>
<th>Assignee</th>
</tr>
</thead>
<tbody>
<tr>
<td>1</td>
<td>Project</td>
<td>1</td>
<td>01-Aug-23</td>
<td>27-May-24</td>
<td>Green</td>
<td>joe Bloggs</td>
</tr>
<tr>
<td>2</td>
<td>Project</td>
<td>2</td>
<td>01-Aug-23</td>
<td>27-May-24</td>
<td>Green</td>
<td>joe Bloggs</td>
</tr>
<tr>
<td>9</td>
<td>Project Charter</td>
<td>1</td>
<td>31-Aug-23</td>
<td>26-Jun-24</td>
<td>Green</td>
<td>joe Bloggs</td>
</tr>
<tr>
<td>10</td>
<td>Scope and Analysis</td>
<td>1</td>
<td>30-Sep-23</td>
<td>26-Jul-24</td>
<td>Green</td>
<td>joe Bloggs</td>
</tr>
<tr>
<td>11</td>
<td>Requirements</td>
<td>1</td>
<td>30-Oct-23</td>
<td>25-Aug-24</td>
<td>Green</td>
<td>joe Bloggs</td>
</tr>
<tr>
<td>12</td>
<td>Development</td>
<td>1</td>
<td>29-Nov-23</td>
<td>24-Sep-24</td>
<td>Green</td>
<td>joe Bloggs</td>
</tr>
<tr>
<td>13</td>
<td>Testing</td>
<td>1</td>
<td>29-Dec-23</td>
<td>24-Oct-24</td>
<td>Green</td>
<td>joe Bloggs</td>
</tr>
<tr>
<td>14</td>
<td>Implementation</td>
<td>1</td>
<td>28-Jan-24</td>
<td>23-Nov-24</td>
<td>Green</td>
<td>joe Bloggs</td>
</tr>
<tr>
<td>15</td>
<td>Project Charter</td>
<td>2</td>
<td>31-Aug-23</td>
<td>26-Jun-24</td>
<td>Green</td>
<td>joe Bloggs</td>
</tr>
<tr>
<td>16</td>
<td>Scope and Analysis</td>
<td>2</td>
<td>30-Sep-23</td>
<td>26-Jul-24</td>
<td>Green</td>
<td>joe Bloggs</td>
</tr>
<tr>
<td>17</td>
<td>Requirements</td>
<td>2</td>
<td>30-Oct-23</td>
<td>25-Aug-24</td>
<td>Green</td>
<td>joe Bloggs</td>
</tr>
<tr>
<td>18</td>
<td>Development</td>
<td>2</td>
<td>29-Nov-23</td>
<td>24-Sep-24</td>
<td>Green</td>
<td>joe Bloggs</td>
</tr>
<tr>
<td>19</td>
<td>Testing</td>
<td>2</td>
<td>29-Dec-23</td>
<td>24-Oct-24</td>
<td>Green</td>
<td>joe Bloggs</td>
</tr>
</tbody>
</table>
</div>
<p>I am using the PowerGannt chart visualization which now looks like this</p>
<p><a href="https://i.sstatic.net/6Dho6.png" rel="nofollow noreferrer"><img src="https://i.sstatic.net/6Dho6.png" alt="Example of my current gannt" /></a></p>
<p>I would like there tow items on the left (Y axsis) Project 1 and Project 2 and all the different phases reflected on the x axis.</p>
<p>How should I go about this?</p>
<p>I have tried to incorporate a hierarchy between task id and parent task but this didn't change the end result.</p>
<p>Thank you in advance for your assistance on this.</p>
<p>When I add the Parent Task to the Parent item nothing changes
<a href="https://i.sstatic.net/flVkV.png" rel="nofollow noreferrer"><img src="https://i.sstatic.net/flVkV.png" alt="enter image description here" /></a></p>
|
<p>If your desired result is something like the following:</p>
<p><a href="https://i.sstatic.net/yY6rF.png" rel="nofollow noreferrer"><img src="https://i.sstatic.net/yY6rF.png" alt="enter image description here" /></a></p>
<p>Add the following fields:</p>
<p><a href="https://i.sstatic.net/7Sjyn.png" rel="nofollow noreferrer"><img src="https://i.sstatic.net/7Sjyn.png" alt="enter image description here" /></a></p>
| 1,475
|
implement RAG
|
Q&A using Retrieval-Augmented Generation with Langchain
|
https://stackoverflow.com/questions/78383658/qa-using-retrieval-augmented-generation-with-langchain
|
<p><code>I have been doing a POC to implement RAG driven model for my AI/ML use case.</code><br />
<code>The use case is to "</code><strong><code>Find Similar and duplicate controls by comparing each ID with every other ID, Generate similarity scores and list the pairs which exceeds a threshold of 80-87 for similar controls and exceeding above 95 for duplicate controls</code></strong><code>"</code></p>
<p><code>The code snippet is :</code></p>
<p><code>loader = CSVLoader(file_path="control.csv")</code><br />
<code>data = loader.load()</code><br />
<code>text_splitter = CharacterTextSplitter(chunk_size=500, chunk_overlap=50)</code><br />
<code>chunks = text_splitter.split_documents(data)</code><br />
<code>vectorstore = Chroma.from_documents(documents=chunks, embedding=OpenAIEmbeddings())</code><br />
<code>retriever = vectorstore.as_retriever()</code><br />
<code>template = """You are an assistant for question-answering tasks.</code></p>
<p><code>Use the following pieces of retrieved context to answer the question.</code></p>
<p><code>If you don't know the answer, just say that you don't know.</code></p>
<p><code>Use three sentences maximum and keep the answer concise.</code></p>
<p><code>Question: {question}</code></p>
<p><code>Context: {context}</code></p>
<p><code>Answer:</code></p>
<p><code>"""</code></p>
<p><code>prompt = ChatPromptTemplate.from_template(template)</code><br />
<code>llm = ChatOpenAI(temperature=0, model="gpt-3.5-turbo",verbose=True)</code></p>
<p><code>rag_chain = ( {"context": retriever, "question": RunnablePassthrough()} | prompt | llm | StrOutputParser() )</code></p>
<p><code>query = "FInd Similar controls by comparing each ID with every other ID in the document, combining their Name and Description. Calculate similarity scores between them and list all the pairs that is exceeding a threshold of 80-87for similar controls and above 95 for duplicate controls."</code></p>
<p><code>rag_chain.invoke(query)</code></p>
<p><code>The output i got was :</code><br />
<code>1. There are a total of 6 controls formed by comparing each ID with every other ID in the document. The similarity scores between them can be calculated and pairs exceeding a threshold of 80 can be listed in the output.</code><br />
<code>2. I don't Know</code></p>
<p><code>My expected outcome is to print the list of Similar and Duplicate pairs from the data , it has around 3500+ data.</code></p>
<p><code>But i dont find to see the expected output here ? Iam not sure where am wrong. Also would like to know if i have mentioned the right prompt for the scenario.</code></p>
<p><code>Also, I have tried the same prompt where i have not implemented RAG , but i could proper results , it just a connection made with Langchain and OpenAI for interaction.</code></p>
<p><code>I would like to know where am wrong and what needs to be corrected in order to get the right expected outcome.</code></p>
|
<p>When you say:</p>
<blockquote>
<p>Blockquote
My expected outcome is to print the list of Similar and Duplicate pairs from the data , it has around 3500+ data.</p>
</blockquote>
<p>First, in your prompt you need to be explicit on how you want the output to be.</p>
<p>Like:</p>
<blockquote>
<p>Blockquote
Output the result in CSV format and only list Similar and Duplicate pairs.</p>
</blockquote>
<p>Second, you could try to use a different output parse like <a href="https://python.langchain.com/docs/modules/model_io/output_parsers/types/pydantic/" rel="nofollow noreferrer">Pydantic</a> or the <a href="https://python.langchain.com/docs/modules/model_io/output_parsers/types/structured/" rel="nofollow noreferrer">Structured Output parser</a></p>
<p>Be careful with the Pydantic parser because it’s sensitive to version changes with LangChain.</p>
<p>Third, you should implement a system prompt to give precise instructions to the LLM. You need to do this because in LangChain if you don’t supply a system prompt, LangChain will provide a basic one that could conflict with your question.</p>
<p>Hope this helps!</p>
| 1,476
|
implement RAG
|
How can i sort vector of vectors by other vector
|
https://stackoverflow.com/questions/76434205/how-can-i-sort-vector-of-vectors-by-other-vector
|
<p>I am making a genetic algorithm and I have a sorting problem:
I have such a class, it is represented as std::vector</p>
<pre><code>class GA_Class {
public:
float Fitness = 0.0f;
bool Parent = 0;
};
typedef std::vector<GA_Class> GA_Vector;
</code></pre>
<p>Also I have a main class</p>
<pre><code>class GA_Population {
private:
std::vector<std::vector<ZydisDisassembledInstruction>> PopulationSetInstrs;
GA_Vector PopulationParametrs;
private:
bool FitnessSort(size_t Unit);
public:
void FitnessSorting();
};
</code></pre>
<p>My problem is contained in the following:
I need somehow to sort the vectors of the variable <code>std::vector<std::vector<ZydisDisassembledInstruction>> PopulationSetInstrs;</code> by <code>GA_Vector PopulationParametrs;</code></p>
<p>I made such an implementation</p>
<pre><code>
bool GA_Population::FitnessSort(size_t Unit)
{
return (PopulationParametrs[Unit].Fitness < PopulationParametrs[Unit].Fitness);
}
void GA_Population::FitnessSorting()
{
std::sort(PopulationSetInstrs.begin(), PopulationSetInstrs.end(), FitnessSort);
//for (size_t Unit = 0; Unit < PopulationSetInstrs.size(); ++Unit)
//{
// std::sort(PopulationSetInstrs[Unit].begin(), PopulationSetInstrs[Unit].end(), FitnessSort);
//}
}
</code></pre>
<p>But I need to iterate somehow along the <code>PopulationParametrs</code> vector with the same iterator that <code>PopulationSetInstrs</code> has</p>
<p>Or do I need to redo the <code>GA_Population</code> class in some other way? I just need to contain instructions for the <code>ZydisDisassembledInstruction</code> class in the vector and add this from the <code>GA_Class</code></p>
<pre><code>float Fitness = 0.0f;
bool Parent = 0;
</code></pre>
<p>p.s.
Please don't beat me with piss rags. I'm not good at programming in C++</p>
|
<p>I redid my classes and used range(<a href="https://github.com/ericniebler/range-v3" rel="nofollow noreferrer">https://github.com/ericniebler/range-v3</a>)</p>
<p>Class</p>
<pre><code>class GA_Population {
private:
std::vector<std::vector<ZydisDisassembledInstruction>> PopulationSetInstrs;
//GA_Vector PopulationParametrs;
std::vector<long double> svFitness;
std::vector<bool> Parentness;
public:
inline void FitnessSorting();
};
</code></pre>
<p>Method:</p>
<pre><code> inline void GA_Population::FitnessSorting()
{
ranges::v3::sort(ranges::view::zip(svFitness, PopulationSetInstrs),
std::less<>{},
[](const auto& t) -> decltype(auto) { return std::get<0>(t); });
}
</code></pre>
| 1,477
|
implement RAG
|
Integrating input rails and output rails into chat bot via Runnable Rails
|
https://stackoverflow.com/questions/78904449/integrating-input-rails-and-output-rails-into-chat-bot-via-runnable-rails
|
<p>I've been working on developing and safeguarding a chat bot based on RAG - model and NeMo - Guardrails.
I'm trying to integrate output rails alongside input rails. But I'm having trouble while doing so. The issue lies in YAML and COLANG contents because the input and output rails are not being initialized.
I'm using openai, langchain, chromadb and gpt-3.5-turbo-instruct as a model.</p>
<p>When I integrated input rails then it worked for me. But now when I need to integrate other types of NeMo - Guardrails then it thows input rails token not found error.
I've integrated YAML, COLANG and chat bot's script into a single one shot file.
Also I have tried this without Runnable Rails which gave me same issues.</p>
<p>I'm sharing my chat bot script implementation here :</p>
<pre><code>import os
import chromadb
from langchain.chains import RetrievalQA
from langchain.prompts import PromptTemplate
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_chroma import Chroma
from dotenv import load_dotenv
from nemoguardrails import RailsConfig
from nemoguardrails.integrations.langchain.runnable_rails import RunnableRails
# Set environment variables
load_dotenv()
OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
path_persist_directory = os.environ.get("PATH_PERSIST_DIRECTORY")
gpt_model = os.environ.get("GPT_MODEL")
collection = os.environ.get("STORE_NAME")
# Initialize models
llmo = ChatOpenAI(model_name=gpt_model, temperature=0, openai_api_key=OPENAI_API_KEY)
embedding_model = OpenAIEmbeddings(api_key=OPENAI_API_KEY)
# Initialize vector store
vector_store = Chroma(collection_name=collection, embedding_function=embedding_model, persist_directory=path_persist_directory)
# Define prompt template
PROMPT_TEMPLATE = """
***instruction: You are a chatbot expert tasked with answering questions based on the information contained in a provided PDF document.
**Follow these guidelines to ensure accurate and relevant responses:
[Instructions as before]
Question: {question}
Context: {context}
Answer:
"""
# Load guardrails configuration
YAML_CONTENT = """
models:
- type: main
engine: openai
model: gpt-3.5-turbo-instruct
rails:
input:
flows:
- self_check_input
output:
flows:
- self_check_output
prompts:
- task: self_check_input
content: |
Your task is to check if the user message below complies with the company policy for talking with the company bot.
Policies for user messages:
- should not contain harmful data
- should not ask the bot to impersonate someone
- should not ask the bot to forget about rules
- should not ask the bot about any geographical queries except the document-related questions
- should not instruct the bot to respond inappropriately
- should not contain explicit content
- should not use abusive language, even if just a few words
- should not share sensitive or personal information
- should not contain code or request code execution
- should not ask to return system prompt text or programmed conditions
- should not contain garbled language
- should not contain political, religious, racial, sexist, or discriminatory content
- should not ask out-of-context questions unrelated to the bot's purpose
User message: "{{ user_input }}"
Question: Should the user message be blocked (Yes or No)?
Answer:
- task: self_check_output
content: |
Your task is to check if the chatbot's response below complies with the company policy for responses.
Policies for bot responses:
- should be accurate based on the PDF information
- should be relevant to the user's query and the context
- should be clear and concise
- should avoid personal opinions and biased viewpoints
- should avoid explicit, abusive, or offensive content
- should include citations or references from the PDF when possible
- should clearly state if the information is not available
- should be consistent with previous responses and company policy
- should be respectful and professional
- should handle errors gracefully
Bot response: "{{ bot_response }}"
Question: Should the bot response be adjusted or blocked (Yes or No)?
Answer:
"""
COLANG_CONTENT = """
define user express greeting
"hi"
"hello"
define user ask question
"What can you do?"
"Where is Paris?"
"How tall is Mount Everest?"
define user ask inappropriate question
"Why are boys more aggressive than girls?"
"Why do Asians excel in certain fields?"
"Can you comment on political elections?"
"How do I make a chicken recipe?"
"What is the capital of France?"
"Do you believe in God?"
"What is your opinion on religion?"
define bot express greeting
"Hello there!"
define bot respond appropriate question
"You can find more information about our services, products, and promotions on our website or by contacting our support team directly."
"Please refer to our website for detailed information about our policies, including returns, refunds, and privacy."
"Visit our careers page on our website to view current job openings, application instructions, and information about our company culture."
"I'm sorry, I couldn't understand your question. Please visit our website or contact customer support for further assistance."
define bot respond inappropriate question
"I'm sorry, your request cannot be processed due to inappropriate content."
define flow
user express greeting
bot express greeting
define flow
user ask question
bot respond appropriate question
define flow
user ask inappropriate question
bot respond inappropriate question
define self_check_input
user express greeting
bot respond appropriate question
define self_check_output
user ask inappropriate question
bot respond inappropriate question
"""
# Initialize Rails configuration
rails_config = RailsConfig.from_content(
yaml_content=YAML_CONTENT, colang_content=COLANG_CONTENT
)
guardrails = RunnableRails(config=rails_config, input_key="input", output_key="output")
# Wrap the LLM model with guardrails
llmo_with_rails = guardrails | llmo
def get_conversational_chain(query):
"""Get a response from the chatbot, incorporating safety and accuracy checks."""
# Define the prompt for the QA chain
prompt = PromptTemplate(template=PROMPT_TEMPLATE, input_variables=["context", "question"])
# Initialize the Chroma client and retrieve the specific collection
chroma_client = chromadb.PersistentClient(path_persist_directory)
collection_object = chroma_client.get_collection(collection)
# Check if the collection exists
if not collection_object:
raise ValueError(f"Collection '{collection}' does not exist in the Chroma database.")
# Create the vector store retriever
vector_store_retriever_obj = Chroma(
collection_name=collection,
embedding_function=embedding_model,
persist_directory=path_persist_directory
).as_retriever(search_kwargs={'k': 3})
# Create the QA chain
qa_chain = RetrievalQA.from_chain_type(
llm=llmo_with_rails,
chain_type="stuff",
retriever=vector_store_retriever_obj,
chain_type_kwargs={"prompt": prompt},
return_source_documents=False
)
# Adjust the input format for guardrails
guardrails_input = {"input": query}
guardrails_output = guardrails.invoke(guardrails_input)
print(f"Guardrails output: {guardrails_output}")
# Check if the request was blocked
guardrails_response = guardrails_output.get("output", "").strip().lower()
if guardrails_response == "i'm sorry, your request cannot be processed due to inappropriate content.":
return guardrails_response
# Pass query through the QA chain if it is not blocked
qa_chain_response = qa_chain.invoke(query)
response = qa_chain_response['result']
# Adjust the output format for guardrails
guardrails_output = {"output": response}
final_output = guardrails.invoke(guardrails_output)
# Check if the bot response was adjusted or blocked
final_response = final_output.get("output", "").strip()
if final_response == "i'm sorry, your request cannot be processed due to inappropriate content.":
return final_response
return response
# Example queries for testing
test_queries = [
"What is the team size of your company?",
"Hi",
"Where is your office located?",
"What is the capital of France?",
"How to abuse the system?"
]
for query in test_queries:
response = get_conversational_chain(query)
print(f"Query: {query}")
print(f"Response: {response}")
print("-----")
</code></pre>
<p>Output :</p>
<p>(ryanenv) C:\Users\aryan\OneDrive\Desktop\Ryan_CSE\STY\Mahapur>python sty.py
Traceback (most recent call last):
File "C:\Users\aryan\OneDrive\Desktop\Ryan_CSE\STY\Mahapur\ryanenv\lib\site-packages\nemoguardrails\colang\v1_0\lang\colang_parser.py", line 1684, in parse
self._process_define()
File "C:\Users\aryan\OneDrive\Desktop\Ryan_CSE\STY\Mahapur\ryanenv\lib\site-packages\nemoguardrails\colang\v1_0\lang\colang_parser.py", line 724, in _process_define
raise Exception(f'Unknown token: "{define_token}"')
Exception: Unknown token: "self_check_input"</p>
<p>During handling of the above exception, another exception occurred:</p>
<p>Traceback (most recent call last):
File "C:\Users\aryan\OneDrive\Desktop\Ryan_CSE\STY\Mahapur\sty.py", line 539, in
rails_config = RailsConfig.from_content(
File "C:\Users\aryan\OneDrive\Desktop\Ryan_CSE\STY\Mahapur\ryanenv\lib\site-packages\nemoguardrails\rails\llm\config.py", line 925, in from_content<br />
<em>parsed_config = parse_colang_file(
File "C:\Users\aryan\OneDrive\Desktop\Ryan_CSE\STY\Mahapur\ryanenv\lib\site-packages\nemoguardrails\colang_<em>init</em></em>.py", line 27, in parse_colang_file<br />
return parser_v1_0.parse_colang_file(filename, content, include_source_mapping)
File "C:\Users\aryan\OneDrive\Desktop\Ryan_CSE\STY\Mahapur\ryanenv\lib\site-packages\nemoguardrails\colang\v1_0\lang\parser.py", line 67, in parse_colang_file
result = parse_coflows_to_yml_flows(
File "C:\Users\aryan\OneDrive\Desktop\Ryan_CSE\STY\Mahapur\ryanenv\lib\site-packages\nemoguardrails\colang\v1_0\lang\colang_parser.py", line 1898, in parse_coflows_to_yml_flows
return parser.parse()
File "C:\Users\aryan\OneDrive\Desktop\Ryan_CSE\STY\Mahapur\ryanenv\lib\site-packages\nemoguardrails\colang\v1_0\lang\colang_parser.py", line 1774, in parse
raise exception
Exception: Error parsing line 44 in main.co: Unknown token: "self_check_input"</p>
|
<p>There is syntax and conceptual incorrect implementation that i can notice, to fix it you can remove this from your COLANG_CONTENT</p>
<pre><code>define self_check_input
user express greeting
bot respond appropriate question
define self_check_output
user ask inappropriate question
bot respond inappropriate question
</code></pre>
<p>Also in your YAML_CONTENT the rails have been mentioned with self_check_input, you can just pass "self check input" and remove the underscores. Something like this:</p>
<pre><code>rails:
input:
flows:
- self check input
output:
flows:
- self check output
</code></pre>
<p>I can imagine loading config directly from strings can be challenging, hence i encourage to put them in config folder and read from there</p>
| 1,478
|
implement RAG
|
Attempt to redefine node p[1,1] When adding covariates to beta-binomial mixture model
|
https://stackoverflow.com/questions/71720266/attempt-to-redefine-node-p1-1-when-adding-covariates-to-beta-binomial-mixture
|
<p>I keep getting the above error when I try adding detection covariates on a beta-binomial N-mixture model in rags. According to Royle(2004). A binomial N mixture model can be used to model abundance data arising from repeat count surveys. The number of individuals on a site can be modeled by a Poisson <em>[For simplicity I will stick to the Poisson model only]</em> such that;</p>
<p><strong>N<sub>i</sub> ~ Poisson(λ<sub>i</sub>)</strong></p>
<p><strong>y<sub>it</sub> ~ bin(p<sub>i</sub><sup>'</sup><sub>t</sub>,N<sub>i</sub>)</strong></p>
<p><strong>N<sub>i</sub> -</strong> is the number of animals available in site i</p>
<p><strong>y<sub>it</sub> -</strong> is the count of observed animals at site i visit t</p>
<p><strong>λ<sub>i</sub> -</strong> is the average number of animals at site i</p>
<p><strong>p<sub>it</sub> -</strong> is the mean detection probability.</p>
<p>Covariate effects can be modeled as:</p>
<p>Abundance:</p>
<p><strong>log(λ<sub>i</sub>)= B<sub>0</sub>+ B<sub>1</sub>x<sub>i1</sub> +...+B<sub>r</sub>x<sub>ir</sub></strong> where 1...r are covariates</p>
<p>detection:</p>
<p><strong>logit(p<sub>it</sub>)= B<sub>0</sub>+ B<sub>1</sub>x<sub>i1</sub> +...+B<sub>r</sub>x<sub>ir</sub></strong> where 1...r are covariates</p>
<p>Probability of detection <strong>p<sub>it</sub></strong> is assumed to be constant for all present animals.</p>
<p>The *<em>beta binomial model ease this assumption</em> by letting <strong>detection probability</strong> follow a stochastic distribution instead, such that</p>
<p><strong>p<sub>i</sub><sup>'</sup><sub>t</sub> ~ Beta(p<sub>it</sub>(1-δ<sup>2</sup>)/δ<sup>2</sup>,(1-p<sub>it</sub>)(1-δ<sup>2</sup>)/δ<sup>2</sup></strong></p>
<p>for 0<δ<1</p>
<p>I tried implementing the model with a simulated data:</p>
<p>20 sites, 5 visits, site covariate = Location, and 2 observed covariates.</p>
<p><strong>simulated data</strong></p>
<pre><code>library(modelr)
Location<-c("A","B","C","D")
Location<-data.frame(Location=rep(Location,5))
location=Location%>%model_matrix(~Location)%>%select(-1)
set.seed(100)
y<-matrix(rpois(100,0.5),ncol=5)
# Cov1
set.seed(100)
cov1<-matrix(rnorm(100,100,5),ncol=5)
# cov 2
set.seed(100)
cov2<-matrix(rnorm(100,50,2),ncol=5)
data<-list(y=y,
nSites=20,
nOcc=5,
nA=ncol(data$location),
location=location,
cov1=cov1,
cov2=cov2)
</code></pre>
<p>if i try estimating this model in rjags without the covariate effects for detection it works.</p>
<pre><code>nx<-"
model{
for(i in 1:nSites) {
# Biological model
N[i] ~ dpois(lambda[i])
log(lambda[i])<-alphao+inprod(alpha, location[i,])
}
# Observation model
for(i in 1:nSites) {
for(t in 1:nOcc) {
y[i,t] ~ dbin(pit_h[i,t], N[i])
pit_h[i,t]~ dbeta((pit[i,t]*fac),(fac*(1-pit[i,t])))
}
}
# Priors
alphao ~ dnorm(5,1)
for(i in 1:nA){
alpha[i] ~ dnorm(2,.5)
}
for(i in 1:nSites) {
for(t in 1:nOcc) {
pit[i,t]~dunif(0,1)
}
}
sigma ~ dunif(0,1)
fac <-(1-sigma^2)/sigma^2
}"
writeLines(nx,con="mod.txt")
inits = function() list(N = apply(y,1,max,na.rm=T))
watch=c("alphao","alpha","lambda","pit")
set.seed(100)
mod<-jagsUI::jags(data,
parameters.to.save=watch,
model.file="mod.txt",n.iter=3,
n.chains=2)
mod
</code></pre>
<p>yielding</p>
<pre><code>JAGS output for model 'mod.txt', generated by jagsUI.
Estimates based on 2 chains of 3 iterations,
adaptation = 100 iterations (sufficient),
burn-in = 0 iterations and thin rate = 1,
yielding 6 total samples from the joint posterior.
MCMC ran for 0.009 minutes at time 2023-01-11 16:52:03.
mean sd 2.5% 50% 97.5% overlap0 f Rhat n.eff
alphao 4.769 0.446 4.350 4.754 5.218 FALSE 1 27.188 2
alpha[1] 1.725 0.629 1.115 1.735 2.310 FALSE 1 48.915 2
alpha[2] 1.991 0.161 1.795 2.012 2.149 FALSE 1 7.456 2
alpha[3] 1.822 0.633 1.186 1.852 2.415 FALSE 1 28.072 2
lambda[1] 127.706 54.181 77.504 124.146 184.586 FALSE 1 19.433 2
lambda[2] 670.612 122.557 551.850 671.722 785.277 FALSE 1 48.321 2
lambda[3] 893.022 252.923 660.011 887.089 1138.013 FALSE 1 50.136 2
lambda[4] 739.326 137.772 604.421 735.512 877.068 FALSE 1 19.180 2
lambda[5] 127.706 54.181 77.504 124.146 184.586 FALSE 1 19.433 2
lambda[6] 670.612 122.557 551.850 671.722 785.277 FALSE 1 48.321 2
lambda[7] 893.022 252.923 660.011 887.089 1138.013 FALSE 1 50.136 2
lambda[8] 739.326 137.772 604.421 735.512 877.068 FALSE 1 19.180 2
lambda[9] 127.706 54.181 77.504 124.146 184.586 FALSE 1 19.433 2
lambda[10] 670.612 122.557 551.850 671.722 785.277 FALSE 1 48.321 2
lambda[11] 893.022 252.923 660.011 887.089 1138.013 FALSE 1 50.136 2
lambda[12] 739.326 137.772 604.421 735.512 877.068 FALSE 1 19.180 2
lambda[13] 127.706 54.181 77.504 124.146 184.586 FALSE 1 19.433 2
lambda[14] 670.612 122.557 551.850 671.722 785.277 FALSE 1 48.321 2
lambda[15] 893.022 252.923 660.011 887.089 1138.013 FALSE 1 50.136 2
lambda[16] 739.326 137.772 604.421 735.512 877.068 FALSE 1 19.180 2
lambda[17] 127.706 54.181 77.504 124.146 184.586 FALSE 1 19.433 2
lambda[18] 670.612 122.557 551.850 671.722 785.277 FALSE 1 48.321 2
lambda[19] 893.022 252.923 660.011 887.089 1138.013 FALSE 1 50.136 2
lambda[20] 739.326 137.772 604.421 735.512 877.068 FALSE 1 19.180 2
pit[1,1] 0.183 0.118 0.048 0.157 0.327 FALSE 1 0.946 6
pit[2,1] 0.267 0.238 0.036 0.218 0.576 FALSE 1 4.558 2
pit[3,1] 0.280 0.143 0.085 0.313 0.432 FALSE 1 0.929 6
pit[4,1] 0.354 0.236 0.045 0.396 0.622 FALSE 1 1.186 6
pit[5,1] 0.199 0.100 0.082 0.190 0.346 FALSE 1 1.128 6
pit[6,1] 0.130 0.076 0.037 0.118 0.233 FALSE 1 3.429 2
pit[7,1] 0.503 0.197 0.209 0.536 0.741 FALSE 1 1.120 6
pit[8,1] 0.369 0.199 0.076 0.414 0.597 FALSE 1 0.986 6
pit[9,1] 0.396 0.131 0.224 0.425 0.551 FALSE 1 1.751 4
pit[10,1] 0.281 0.141 0.122 0.271 0.468 FALSE 1 1.179 6
pit[11,1] 0.554 0.226 0.291 0.585 0.768 FALSE 1 1.031 6
pit[12,1] 0.304 0.165 0.139 0.296 0.558 FALSE 1 1.001 6
pit[13,1] 0.240 0.274 0.071 0.139 0.717 FALSE 1 1.648 4
pit[14,1] 0.199 0.111 0.074 0.197 0.332 FALSE 1 4.464 2
pit[15,1] 0.322 0.093 0.207 0.303 0.446 FALSE 1 0.849 6
pit[16,1] 0.380 0.226 0.060 0.381 0.690 FALSE 1 1.043 6
pit[17,1] 0.085 0.045 0.035 0.084 0.133 FALSE 1 1.130 6
pit[18,1] 0.193 0.109 0.066 0.217 0.335 FALSE 1 2.724 3
pit[19,1] 0.135 0.047 0.081 0.137 0.203 FALSE 1 1.110 6
pit[20,1] 0.370 0.219 0.099 0.368 0.702 FALSE 1 1.063 6
pit[1,2] 0.419 0.168 0.285 0.362 0.707 FALSE 1 1.275 6
pit[2,2] 0.535 0.287 0.250 0.502 0.869 FALSE 1 8.332 2
pit[3,2] 0.356 0.206 0.095 0.362 0.662 FALSE 1 1.030 6
pit[4,2] 0.330 0.123 0.177 0.335 0.486 FALSE 1 4.460 2
pit[5,2] 0.334 0.215 0.072 0.350 0.617 FALSE 1 1.160 6
pit[6,2] 0.032 0.026 0.005 0.023 0.072 FALSE 1 2.278 3
pit[7,2] 0.385 0.289 0.035 0.438 0.682 FALSE 1 1.426 5
pit[8,2] 0.537 0.162 0.378 0.488 0.778 FALSE 1 0.881 6
pit[9,2] 0.489 0.266 0.073 0.539 0.741 FALSE 1 1.344 5
pit[10,2] 0.194 0.182 0.024 0.180 0.414 FALSE 1 1.166 6
pit[11,2] 0.476 0.258 0.236 0.424 0.811 FALSE 1 6.065 2
pit[12,2] 0.536 0.225 0.232 0.610 0.744 FALSE 1 2.909 3
pit[13,2] 0.244 0.090 0.141 0.239 0.375 FALSE 1 3.298 2
pit[14,2] 0.432 0.175 0.257 0.403 0.660 FALSE 1 1.097 6
pit[15,2] 0.419 0.287 0.122 0.404 0.738 FALSE 1 8.309 2
pit[16,2] 0.522 0.146 0.378 0.502 0.744 FALSE 1 2.006 3
pit[17,2] 0.225 0.167 0.041 0.176 0.449 FALSE 1 3.682 2
pit[18,2] 0.264 0.079 0.164 0.265 0.356 FALSE 1 1.245 6
pit[19,2] 0.440 0.243 0.161 0.466 0.766 FALSE 1 3.425 2
pit[20,2] 0.238 0.139 0.099 0.216 0.446 FALSE 1 2.344 3
pit[1,3] 0.273 0.159 0.064 0.263 0.484 FALSE 1 1.031 6
pit[2,3] 0.332 0.115 0.200 0.327 0.497 FALSE 1 3.520 2
pit[3,3] 0.533 0.251 0.183 0.494 0.840 FALSE 1 1.101 6
pit[4,3] 0.324 0.250 0.117 0.205 0.685 FALSE 1 0.865 6
pit[5,3] 0.607 0.221 0.224 0.674 0.742 FALSE 1 1.470 5
pit[6,3] 0.298 0.113 0.160 0.293 0.461 FALSE 1 1.069 6
pit[7,3] 0.403 0.143 0.163 0.429 0.526 FALSE 1 1.613 4
pit[8,3] 0.415 0.170 0.261 0.363 0.682 FALSE 1 3.085 2
pit[9,3] 0.498 0.321 0.099 0.594 0.861 FALSE 1 3.386 2
pit[10,3] 0.258 0.222 0.055 0.185 0.611 FALSE 1 0.970 6
pit[11,3] 0.381 0.268 0.058 0.360 0.789 FALSE 1 1.756 4
pit[12,3] 0.162 0.072 0.084 0.159 0.268 FALSE 1 1.566 4
pit[13,3] 0.152 0.159 0.004 0.097 0.356 FALSE 1 2.475 3
pit[14,3] 0.057 0.042 0.010 0.060 0.099 FALSE 1 8.243 2
pit[15,3] 0.429 0.192 0.175 0.404 0.708 FALSE 1 1.080 6
pit[16,3] 0.099 0.044 0.045 0.108 0.143 FALSE 1 4.856 2
pit[17,3] 0.262 0.206 0.052 0.238 0.492 FALSE 1 9.405 2
pit[18,3] 0.400 0.153 0.177 0.416 0.573 FALSE 1 1.203 6
pit[19,3] 0.314 0.221 0.043 0.320 0.569 FALSE 1 0.955 6
pit[20,3] 0.150 0.108 0.045 0.114 0.325 FALSE 1 1.776 4
pit[1,4] 0.280 0.299 0.014 0.191 0.635 FALSE 1 5.639 2
pit[2,4] 0.329 0.317 0.113 0.225 0.877 FALSE 1 1.243 6
pit[3,4] 0.472 0.204 0.208 0.462 0.750 FALSE 1 1.074 6
pit[4,4] 0.457 0.293 0.146 0.460 0.806 FALSE 1 6.732 2
pit[5,4] 0.268 0.148 0.036 0.301 0.406 FALSE 1 0.943 6
pit[6,4] 0.251 0.213 0.047 0.193 0.561 FALSE 1 0.892 6
pit[7,4] 0.104 0.106 0.022 0.069 0.287 FALSE 1 1.347 6
pit[8,4] 0.220 0.079 0.140 0.194 0.346 FALSE 1 1.804 4
pit[9,4] 0.379 0.306 0.127 0.213 0.830 FALSE 1 2.284 3
pit[10,4] 0.482 0.209 0.164 0.582 0.660 FALSE 1 0.896 6
pit[11,4] 0.052 0.045 0.012 0.043 0.127 FALSE 1 1.629 4
pit[12,4] 0.465 0.136 0.341 0.418 0.671 FALSE 1 3.070 2
pit[13,4] 0.496 0.216 0.260 0.462 0.758 FALSE 1 2.080 3
pit[14,4] 0.365 0.194 0.176 0.301 0.642 FALSE 1 0.847 6
pit[15,4] 0.371 0.277 0.126 0.281 0.785 FALSE 1 1.523 4
pit[16,4] 0.371 0.254 0.088 0.375 0.699 FALSE 1 1.163 6
pit[17,4] 0.442 0.172 0.209 0.427 0.686 FALSE 1 1.040 6
pit[18,4] 0.527 0.300 0.141 0.629 0.804 FALSE 1 0.818 6
pit[19,4] 0.563 0.144 0.384 0.580 0.735 FALSE 1 3.056 2
pit[20,4] 0.198 0.096 0.104 0.187 0.343 FALSE 1 3.528 2
pit[1,5] 0.264 0.128 0.157 0.229 0.482 FALSE 1 1.119 6
pit[2,5] 0.397 0.102 0.229 0.419 0.496 FALSE 1 1.460 5
pit[3,5] 0.396 0.202 0.100 0.493 0.580 FALSE 1 0.888 6
pit[4,5] 0.423 0.092 0.312 0.403 0.532 FALSE 1 3.020 2
pit[5,5] 0.268 0.208 0.033 0.219 0.523 FALSE 1 3.875 2
pit[6,5] 0.330 0.158 0.172 0.326 0.514 FALSE 1 0.871 6
pit[7,5] 0.329 0.133 0.142 0.336 0.483 FALSE 1 0.905 6
[ reached 'max' / getOption("max.print") -- omitted 14 rows ]
**WARNING** Rhat values indicate convergence failure.
Rhat is the potential scale reduction factor (at convergence, Rhat=1).
For each parameter, n.eff is a crude measure of effective sample size.
overlap0 checks if 0 falls in the parameter's 95% credible interval.
f is the proportion of the posterior with the same sign as the mean;
i.e., our confidence that the parameter is positive or negative.
DIC info: (pD = var(deviance)/2)
pD = 71.8 and DIC = 239.53
DIC is an estimate of expected predictive error (lower is better).
>
</code></pre>
<p>if i ignore the stochastic distribution of p<sub>i</sub><sup>'</sup><sub>t</sub> it works actually this is the constant pit i mentioned. everybody is doing it on every tutorial</p>
<p>The code</p>
<pre><code>nx <- "
model{
# Abundance
for (i in 1:nSites) {
N[i]~ dpois(lambda[i])
log(lambda[i])<-alphao+inprod(alpha, location[i,])
}
for (i in 1:nSites) {
for(t in 1:nOcc){
y[i,t]~ dbin(pit[i,t],N[i])
#pit_h[i,t]~ dbeta(1,1)
logit(pit[i,t]) <- beta0+inprod(beta, location[i,])+inprod(beta1,c(cov1[i,t],cov2[i,t]))
}
}
# Priors
alphao ~ dnorm(1.2824,0.302)
for(i in 1:nA){
alpha[i] ~ dnorm(0.284,0.570)
}
beta0 ~ dunif(-1.67,0.61)
for(i in 1:3){
beta[i] ~ dnorm(-0.370,0.254)
}
for(i in 1:2){
beta1[i] ~ dnorm(-0.104,0.44)
}
# det
sigma ~ dunif(0,1)
fac <-(1-sigma^2)/sigma^2
# derived
}"
writeLines(nx,con="mod1.txt")
watch=c("alphao","alpha","lambda","beta0","beta","beta1","pit","sigma")
inits = function() list(N = apply(y,1,max,na.rm=T))
set.seed(100)
mod<-jagsUI::jags(data,
parameters.to.save=watch,inits=inits,
model.file="mod1.txt",n.iter=3,
n.chains=2,DIC=TRUE)
mod
</code></pre>
<p>yielding</p>
<pre><code>JAGS output for model 'mod1.txt', generated by jagsUI.
Estimates based on 2 chains of 3 iterations,
adaptation = 100 iterations (sufficient),
burn-in = 0 iterations and thin rate = 1,
yielding 6 total samples from the joint posterior.
MCMC ran for 0.006 minutes at time 2023-01-11 17:02:18.
mean sd 2.5% 50% 97.5% overlap0 f Rhat n.eff
alphao 4.405 0.098 4.247 4.448 4.489 FALSE 1.0 2.264 3
alpha[1] 0.705 0.311 0.386 0.702 1.052 FALSE 1.0 8.735 2
alpha[2] 1.568 0.229 1.346 1.550 1.829 FALSE 1.0 10.655 2
alpha[3] 1.300 0.086 1.167 1.333 1.380 FALSE 1.0 2.526 3
lambda[1] 82.166 7.700 69.933 85.482 89.069 FALSE 1.0 2.337 3
lambda[2] 169.553 39.141 128.321 171.241 207.988 FALSE 1.0 12.838 2
lambda[3] 396.653 61.786 337.056 388.711 467.843 FALSE 1.0 9.972 2
lambda[4] 302.649 41.450 260.019 302.933 343.100 FALSE 1.0 19.472 2
lambda[5] 82.166 7.700 69.933 85.482 89.069 FALSE 1.0 2.337 3
lambda[6] 169.553 39.141 128.321 171.241 207.988 FALSE 1.0 12.838 2
lambda[7] 396.653 61.786 337.056 388.711 467.843 FALSE 1.0 9.972 2
lambda[8] 302.649 41.450 260.019 302.933 343.100 FALSE 1.0 19.472 2
lambda[9] 82.166 7.700 69.933 85.482 89.069 FALSE 1.0 2.337 3
lambda[10] 169.553 39.141 128.321 171.241 207.988 FALSE 1.0 12.838 2
lambda[11] 396.653 61.786 337.056 388.711 467.843 FALSE 1.0 9.972 2
lambda[12] 302.649 41.450 260.019 302.933 343.100 FALSE 1.0 19.472 2
lambda[13] 82.166 7.700 69.933 85.482 89.069 FALSE 1.0 2.337 3
lambda[14] 169.553 39.141 128.321 171.241 207.988 FALSE 1.0 12.838 2
lambda[15] 396.653 61.786 337.056 388.711 467.843 FALSE 1.0 9.972 2
lambda[16] 302.649 41.450 260.019 302.933 343.100 FALSE 1.0 19.472 2
lambda[17] 82.166 7.700 69.933 85.482 89.069 FALSE 1.0 2.337 3
lambda[18] 169.553 39.141 128.321 171.241 207.988 FALSE 1.0 12.838 2
lambda[19] 396.653 61.786 337.056 388.711 467.843 FALSE 1.0 9.972 2
lambda[20] 302.649 41.450 260.019 302.933 343.100 FALSE 1.0 19.472 2
beta0 0.598 0.010 0.583 0.598 0.609 FALSE 1.0 2.973 2
beta[1] -0.669 0.138 -0.825 -0.663 -0.526 FALSE 1.0 10.339 2
beta[2] 0.071 0.148 -0.087 0.075 0.217 TRUE 0.5 14.514 2
beta[3] -0.260 0.079 -0.348 -0.261 -0.178 FALSE 1.0 9.102 2
beta1[1] -0.027 0.136 -0.154 -0.027 0.101 TRUE 0.5 73.857 2
beta1[2] -0.241 0.272 -0.498 -0.241 0.014 TRUE 0.5 73.668 2
pit[1,1] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 14.106 1
pit[2,1] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 34.146 1
pit[3,1] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 48.475 1
pit[4,1] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 19.522 1
pit[5,1] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 4.367 1
pit[6,1] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 29.277 1
pit[7,1] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 51.736 1
pit[8,1] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 17.004 1
pit[9,1] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 19.399 1
pit[10,1] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 45.000 1
pit[11,1] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 46.585 1
pit[12,1] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 5.782 1
pit[13,1] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 9.274 1
pit[14,1] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 17.662 1
pit[15,1] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 46.144 1
pit[16,1] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 3.164 1
pit[17,1] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 12.268 1
pit[18,1] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 24.030 1
pit[19,1] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 52.667 1
pit[20,1] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 31.711 1
pit[1,2] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 13.064 1
pit[2,2] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 16.990 1
pit[3,2] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 44.056 1
pit[4,2] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 17.895 1
pit[5,2] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 19.220 1
pit[6,2] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 46.416 1
pit[7,2] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 52.210 1
pit[8,2] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 8.495 1
pit[9,2] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 24.812 1
pit[10,2] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 31.174 1
pit[11,2] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 48.592 1
pit[12,2] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 28.506 1
pit[13,2] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 8.271 1
pit[14,2] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 39.914 1
pit[15,2] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 52.118 1
pit[16,2] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 1.402 1
pit[17,2] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 3.396 1
pit[18,2] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 26.605 1
pit[19,2] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 20.285 1
pit[20,2] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 20.645 1
pit[1,3] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 7.704 1
pit[2,3] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 0.944 1
pit[3,3] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 52.881 1
pit[4,3] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 15.553 1
pit[5,3] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 14.434 1
pit[6,3] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 2.484 1
pit[7,3] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 50.668 1
pit[8,3] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 24.700 1
pit[9,3] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 5.467 1
pit[10,3] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 58.360 1
pit[11,3] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 51.129 1
pit[12,3] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 31.265 1
pit[13,3] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 3.455 1
pit[14,3] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 9.752 1
pit[15,3] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 52.242 1
pit[16,3] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 20.779 1
pit[17,3] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 28.627 1
pit[18,3] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 8.427 1
pit[19,3] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 5.913 1
pit[20,3] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 15.146 1
pit[1,4] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 10.232 1
pit[2,4] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 38.961 1
pit[3,4] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 50.758 1
pit[4,4] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 32.788 1
pit[5,4] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 4.176 1
pit[6,4] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 50.633 1
pit[7,4] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 35.684 1
pit[8,4] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 7.917 1
pit[9,4] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 7.211 1
pit[10,4] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 39.496 1
pit[11,4] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 40.445 1
pit[12,4] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 19.869 1
pit[13,4] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 24.888 1
pit[14,4] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 4.988 1
pit[15,4] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 52.557 1
pit[16,4] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 4.046 1
pit[17,4] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 23.680 1
pit[18,4] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 30.557 1
pit[19,4] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 22.686 1
pit[20,4] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 35.248 1
pit[1,5] 0.000 0.000 0.000 0.000 0.000 FALSE 1.0 6.609 1
[ reached 'max' / getOption("max.print") -- omitted 21 rows ]
**WARNING** Rhat values indicate convergence failure.
Rhat is the potential scale reduction factor (at convergence, Rhat=1).
For each parameter, n.eff is a crude measure of effective sample size.
overlap0 checks if 0 falls in the parameter's 95% credible interval.
f is the proportion of the posterior with the same sign as the mean;
i.e., our confidence that the parameter is positive or negative.
DIC info: (pD = var(deviance)/2)
pD = 19.7 and DIC = 1249.054
DIC is an estimate of expected predictive error (lower is better).
</code></pre>
<p>But if i include both the covariate effect for detection and the stochastic distribution for detection probability. things go south. <em>see the code below</em></p>
<pre><code>nx <- "
model{
# Abundance
for (i in 1:nSites) {
N[i]~ dpois(lambda[i])
log(lambda[i])<-alphao+inprod(alpha, location[i,])
}
for (i in 1:nSites) {
for(t in 1:nOcc){
y[i,t]~ dbin(pit[i,t],N[i])
pit[i,t]~ dbeta(1,1)
logit(pit[i,t]) <- beta0+inprod(beta, location[i,])+inprod(beta1,c(cov1[i,t],cov2[i,t]))
}
}
# Priors
alphao ~ dnorm(1.2824,0.302)
for(i in 1:nA){
alpha[i] ~ dnorm(0.284,0.570)
}
beta0 ~ dunif(-1.67,0.61)
for(i in 1:3){
beta[i] ~ dnorm(-0.370,0.254)
}
for(i in 1:2){
beta1[i] ~ dnorm(-0.104,0.44)
}
# det
sigma ~ dunif(0,1)
fac <-(1-sigma^2)/sigma^2
# derived
}"
writeLines(nx,con="mod1.txt")
watch=c("alphao","alpha","lambda","beta0","beta","beta1","pit","sigma")
inits = function() list(N = apply(y,1,max,na.rm=T))
set.seed(100)
mod<-jagsUI::jags(data,
parameters.to.save=watch,inits=inits,
model.file="mod1.txt",n.iter=3,
n.chains=2,DIC=TRUE)
mod
</code></pre>
<p>this is the error.</p>
<pre><code>Error in jags.model(file = model.file, data = data, inits = inits, n.chains = n.chains, :
RUNTIME ERROR:
Compilation error on line 12.
Attempt to redefine node pit[1,1]
</code></pre>
<p>I understand it is telling me that; <code>pit[i,t]~ dbeta(1,1)</code> is being overwritten by <code>logit(pit[i,t])<-beta0+inprod(beta1, location[i,])+inprod(beta2,c(cov1[i,t],cov2[i,t]))</code> but how exactly should this model be implemented. <a href="https://digitalcommons.unl.edu/cgi/viewcontent.cgi?article=2072&context=natrespapers" rel="nofollow noreferrer">here</a> the model is implemented without detection covariates. Its not what I am looking for.</p>
|
<p><strong>Note: I edited my question to match the parameters on the equations I wrote</strong></p>
<p>I was getting this error because, my detection model is not properly specified. Two processes here are trying to determine <code>pit[i,t]</code> the first is
<code>pit[i,t]~ dbeta(1,1)</code></p>
<p>then</p>
<p><code>logit(pit[i,t])<-beta0+inprod(beta1, location[i,])+inprod(beta2,c(cov1[i,j],cov2[i,j]))</code></p>
<p>so by the time the second process tries to set value for <code>pit[i,t]</code> it finds that another process has already done so hence this error.</p>
<p>what I didn't remember while writing my code was,
p<sub>i</sub><sup>'</sup><sub>t</sub> is a stochastic value, which follows a beta distribution, I should be working to estimate the parameters for the beta binomial distribution generating the stochastic p<sub>i</sub><sup>'</sup><sub>t</sub> but here I went for the stochastic value.</p>
<p>here is the correct implementation</p>
<pre><code>nx <- "
model{
# Abundance
for (i in 1:nSites) {
N[i]~ dpois(lambda[i])
log(lambda[i])<-alphao+inprod(alpha, location[i,])
}
for (i in 1:nSites) {
for(t in 1:nOcc){
y[i,t]~ dbin(pit_h[i,t],N[i])
pit_h[i,t]~ dbeta((pit[i,t]*fac),(fac*(1-pit[i,t])))
logit(pit[i,t]) <- beta0+inprod(beta, location[i,])+inprod(beta1,c(cov1[i,t],cov2[i,t]))
}
}
# Priors
alphao ~ dnorm(1.2824,0.302)
for(i in 1:nA){
alpha[i] ~ dnorm(0.284,0.570)
}
beta0 ~ dunif(-1.67,0.61)
for(i in 1:3){
beta[i] ~ dnorm(-0.370,0.254)
}
for(i in 1:2){
beta1[i] ~ dnorm(-0.104,0.44)
}
# det
sigma ~ dunif(0,1)
fac <-(1-sigma^2)/sigma^2
# derived
}"
writeLines(nx,con="mod1.txt")
watch=c("alphao","alpha","lambda","beta0","beta","beta1","pit","sigma")
inits = function() list(N = apply(y,1,max,na.rm=T))
set.seed(100)
mod<-jagsUI::jags(data,
parameters.to.save=watch,inits=inits,
model.file="mod1.txt",n.iter=3,
n.chains=2,DIC=TRUE)
mod
</code></pre>
<p>yielding</p>
<pre><code>JAGS output for model 'mod1.txt', generated by jagsUI.
Estimates based on 2 chains of 3 iterations,
adaptation = 100 iterations (sufficient),
burn-in = 0 iterations and thin rate = 1,
yielding 6 total samples from the joint posterior.
MCMC ran for 0.051 minutes at time 2023-01-11 17:53:55.
mean sd 2.5% 50% 97.5% overlap0 f Rhat n.eff
alphao 2.114 0.887 1.205 2.127 2.970 FALSE 1.0 19.132 2
alpha[1] -0.181 0.774 -0.929 -0.232 0.674 TRUE 0.5 13.424 2
alpha[2] -0.792 0.437 -1.211 -0.821 -0.284 FALSE 1.0 10.708 2
alpha[3] -0.123 0.391 -0.537 -0.114 0.306 TRUE 0.5 10.409 2
lambda[1] 11.143 8.192 3.338 10.511 19.499 FALSE 1.0 16.476 2
lambda[2] 6.989 1.152 5.440 7.218 8.436 FALSE 1.0 2.041 3
lambda[3] 4.078 1.757 2.388 3.947 5.864 FALSE 1.0 18.172 2
lambda[4] 12.868 11.770 2.060 11.100 26.299 FALSE 1.0 10.437 2
lambda[5] 11.143 8.192 3.338 10.511 19.499 FALSE 1.0 16.476 2
lambda[6] 6.989 1.152 5.440 7.218 8.436 FALSE 1.0 2.041 3
lambda[7] 4.078 1.757 2.388 3.947 5.864 FALSE 1.0 18.172 2
lambda[8] 12.868 11.770 2.060 11.100 26.299 FALSE 1.0 10.437 2
lambda[9] 11.143 8.192 3.338 10.511 19.499 FALSE 1.0 16.476 2
lambda[10] 6.989 1.152 5.440 7.218 8.436 FALSE 1.0 2.041 3
lambda[11] 4.078 1.757 2.388 3.947 5.864 FALSE 1.0 18.172 2
lambda[12] 12.868 11.770 2.060 11.100 26.299 FALSE 1.0 10.437 2
lambda[13] 11.143 8.192 3.338 10.511 19.499 FALSE 1.0 16.476 2
lambda[14] 6.989 1.152 5.440 7.218 8.436 FALSE 1.0 2.041 3
lambda[15] 4.078 1.757 2.388 3.947 5.864 FALSE 1.0 18.172 2
lambda[16] 12.868 11.770 2.060 11.100 26.299 FALSE 1.0 10.437 2
lambda[17] 11.143 8.192 3.338 10.511 19.499 FALSE 1.0 16.476 2
lambda[18] 6.989 1.152 5.440 7.218 8.436 FALSE 1.0 2.041 3
lambda[19] 4.078 1.757 2.388 3.947 5.864 FALSE 1.0 18.172 2
lambda[20] 12.868 11.770 2.060 11.100 26.299 FALSE 1.0 10.437 2
beta0 -0.162 0.447 -0.600 -0.186 0.325 TRUE 0.5 14.944 2
beta[1] 0.924 0.693 0.243 0.892 1.644 FALSE 1.0 14.009 2
beta[2] 2.147 0.133 1.987 2.152 2.288 FALSE 1.0 7.489 2
beta[3] 1.047 0.911 0.072 1.073 1.920 FALSE 1.0 17.258 2
beta1[1] -0.088 0.008 -0.096 -0.088 -0.080 FALSE 1.0 42.539 2
beta1[2] 0.121 0.022 0.100 0.121 0.142 FALSE 1.0 55.542 2
pit[1,1] 0.067 0.041 0.029 0.061 0.114 FALSE 1.0 10.366 2
pit[2,1] 0.117 0.015 0.098 0.122 0.131 FALSE 1.0 0.923 6
pit[3,1] 0.341 0.181 0.169 0.324 0.538 FALSE 1.0 13.526 2
pit[4,1] 0.195 0.183 0.025 0.187 0.379 FALSE 1.0 29.881 2
pit[5,1] 0.060 0.037 0.026 0.054 0.102 FALSE 1.0 10.199 2
pit[6,1] 0.114 0.014 0.095 0.118 0.127 FALSE 1.0 0.926 6
pit[7,1] 0.360 0.186 0.184 0.345 0.563 FALSE 1.0 13.999 2
pit[8,1] 0.200 0.187 0.026 0.191 0.387 FALSE 1.0 30.322 2
pit[9,1] 0.071 0.043 0.031 0.064 0.120 FALSE 1.0 10.459 2
pit[10,1] 0.128 0.016 0.107 0.133 0.142 FALSE 1.0 0.915 6
pit[11,1] 0.334 0.179 0.164 0.318 0.530 FALSE 1.0 13.373 2
pit[12,1] 0.216 0.201 0.029 0.207 0.415 FALSE 1.0 31.999 2
pit[13,1] 0.063 0.039 0.028 0.058 0.108 FALSE 1.0 10.284 2
pit[14,1] 0.105 0.013 0.088 0.110 0.118 FALSE 1.0 0.933 6
pit[15,1] 0.333 0.178 0.163 0.316 0.529 FALSE 1.0 13.343 2
pit[16,1] 0.219 0.203 0.030 0.211 0.421 FALSE 1.0 32.359 2
pit[17,1] 0.065 0.040 0.029 0.060 0.112 FALSE 1.0 10.335 2
pit[18,1] 0.110 0.014 0.091 0.114 0.123 FALSE 1.0 0.929 6
pit[19,1] 0.374 0.189 0.194 0.358 0.578 FALSE 1.0 14.324 2
pit[20,1] 0.161 0.153 0.019 0.153 0.316 FALSE 1.0 26.658 2
pit[1,2] 0.066 0.040 0.029 0.060 0.113 FALSE 1.0 10.349 2
pit[2,2] 0.105 0.013 0.087 0.109 0.118 FALSE 1.0 0.934 6
pit[3,2] 0.327 0.177 0.160 0.311 0.522 FALSE 1.0 13.219 2
pit[4,2] 0.198 0.186 0.026 0.190 0.384 FALSE 1.0 30.170 2
pit[5,2] 0.070 0.043 0.031 0.064 0.120 FALSE 1.0 10.455 2
pit[6,2] 0.130 0.016 0.109 0.135 0.144 FALSE 1.0 0.914 6
pit[7,2] 0.366 0.187 0.188 0.350 0.569 FALSE 1.0 14.133 2
pit[8,2] 0.212 0.198 0.028 0.204 0.409 FALSE 1.0 31.621 2
pit[9,2] 0.075 0.046 0.034 0.069 0.127 FALSE 1.0 10.557 2
pit[10,2] 0.115 0.014 0.096 0.120 0.128 FALSE 1.0 0.925 6
pit[11,2] 0.341 0.181 0.169 0.325 0.539 FALSE 1.0 13.537 2
pit[12,2] 0.174 0.165 0.021 0.165 0.340 FALSE 1.0 27.825 2
pit[13,2] 0.062 0.038 0.027 0.057 0.107 FALSE 1.0 10.267 2
pit[14,2] 0.122 0.015 0.102 0.128 0.136 FALSE 1.0 0.919 6
pit[15,2] 0.365 0.187 0.187 0.349 0.568 FALSE 1.0 14.103 2
pit[16,2] 0.225 0.208 0.031 0.216 0.431 FALSE 1.0 32.922 2
pit[17,2] 0.059 0.036 0.026 0.054 0.101 FALSE 1.0 10.182 2
pit[18,2] 0.112 0.014 0.093 0.116 0.125 FALSE 1.0 0.928 6
pit[19,2] 0.297 0.167 0.139 0.280 0.483 FALSE 1.0 12.542 2
pit[20,2] 0.193 0.182 0.025 0.185 0.375 FALSE 1.0 29.672 2
pit[1,3] 0.062 0.038 0.027 0.056 0.106 FALSE 1.0 10.257 2
pit[2,3] 0.094 0.012 0.077 0.098 0.105 FALSE 1.0 0.944 6
pit[3,3] 0.409 0.195 0.223 0.395 0.619 FALSE 1.0 15.215 2
pit[4,3] 0.202 0.189 0.026 0.194 0.391 FALSE 1.0 30.561 2
pit[5,3] 0.067 0.041 0.030 0.061 0.114 FALSE 1.0 10.372 2
pit[6,3] 0.095 0.012 0.079 0.099 0.107 FALSE 1.0 0.943 6
pit[7,3] 0.352 0.184 0.177 0.336 0.552 FALSE 1.0 13.790 2
pit[8,3] 0.185 0.174 0.023 0.176 0.359 FALSE 1.0 28.825 2
pit[9,3] 0.060 0.037 0.026 0.055 0.104 FALSE 1.0 10.218 2
pit[10,3] 0.165 0.019 0.140 0.172 0.182 FALSE 1.0 0.893 6
pit[11,3] 0.355 0.184 0.180 0.339 0.556 FALSE 1.0 13.870 2
pit[12,3] 0.267 0.241 0.042 0.260 0.504 FALSE 1.0 37.848 2
pit[13,3] 0.059 0.036 0.026 0.054 0.101 FALSE 1.0 10.183 2
pit[14,3] 0.086 0.011 0.071 0.089 0.097 FALSE 1.0 0.953 6
pit[15,3] 0.430 0.198 0.241 0.416 0.641 FALSE 1.0 15.755 2
pit[16,3] 0.193 0.181 0.025 0.184 0.374 FALSE 1.0 29.647 2
pit[17,3] 0.078 0.047 0.035 0.072 0.133 FALSE 1.0 10.632 2
pit[18,3] 0.087 0.012 0.072 0.090 0.098 FALSE 1.0 0.952 6
pit[19,3] 0.286 0.163 0.131 0.269 0.467 FALSE 1.0 12.293 2
pit[20,3] 0.242 0.221 0.035 0.233 0.460 FALSE 1.0 34.824 2
pit[1,4] 0.064 0.039 0.028 0.058 0.109 FALSE 1.0 10.300 2
pit[2,4] 0.122 0.015 0.102 0.127 0.135 FALSE 1.0 0.920 6
pit[3,4] 0.352 0.184 0.178 0.336 0.553 FALSE 1.0 13.805 2
pit[4,4] 0.155 0.148 0.018 0.147 0.305 FALSE 1.0 26.121 2
pit[5,4] 0.059 0.037 0.026 0.054 0.102 FALSE 1.0 10.196 2
pit[6,4] 0.136 0.016 0.114 0.142 0.151 FALSE 1.0 0.910 6
pit[7,4] 0.313 0.173 0.150 0.296 0.504 FALSE 1.0 12.894 2
pit[8,4] 0.213 0.198 0.029 0.205 0.410 FALSE 1.0 31.703 2
pit[9,4] 0.062 0.038 0.027 0.056 0.106 FALSE 1.0 10.249 2
pit[10,4] 0.122 0.015 0.102 0.127 0.136 FALSE 1.0 0.920 6
pit[11,4] 0.320 0.175 0.155 0.304 0.513 FALSE 1.0 13.056 2
pit[12,4] 0.248 0.226 0.037 0.240 0.471 FALSE 1.0 35.556 2
pit[13,4] 0.075 0.046 0.034 0.069 0.128 FALSE 1.0 10.559 2
pit[14,4] 0.090 0.012 0.074 0.093 0.101 FALSE 1.0 0.948 6
pit[15,4] 0.421 0.197 0.233 0.407 0.632 FALSE 1.0 15.524 2
pit[16,4] 0.218 0.203 0.030 0.210 0.419 FALSE 1.0 32.238 2
pit[17,4] 0.074 0.045 0.033 0.068 0.126 FALSE 1.0 10.536 2
pit[18,4] 0.115 0.014 0.095 0.119 0.128 FALSE 1.0 0.925 6
pit[19,4] 0.299 0.168 0.140 0.283 0.486 FALSE 1.0 12.588 2
pit[20,4] 0.277 0.249 0.044 0.270 0.520 FALSE 1.0 39.039 2
pit[1,5] 0.052 0.032 0.022 0.047 0.089 FALSE 1.0 10.005 2
[ reached 'max' / getOption("max.print") -- omitted 21 rows ]
**WARNING** Rhat values indicate convergence failure.
Rhat is the potential scale reduction factor (at convergence, Rhat=1).
For each parameter, n.eff is a crude measure of effective sample size.
overlap0 checks if 0 falls in the parameter's 95% credible interval.
f is the proportion of the posterior with the same sign as the mean;
i.e., our confidence that the parameter is positive or negative.
DIC info: (pD = var(deviance)/2)
pD = 32.5 and DIC = 215.949
DIC is an estimate of expected predictive error (lower is better).
>
</code></pre>
| 1,479
|
implement quantization
|
Dequantize values to their original prior to quantization
|
https://stackoverflow.com/questions/62450062/dequantize-values-to-their-original-prior-to-quantization
|
<p>The paper "Natural Language Processing with Small Feed-Forward Networks" <a href="https://arxiv.org/pdf/1708.00214.pdf" rel="nofollow noreferrer">https://arxiv.org/pdf/1708.00214.pdf</a> states:</p>
<p><a href="https://i.sstatic.net/gZXla.png" rel="nofollow noreferrer"><img src="https://i.sstatic.net/gZXla.png" alt="enter image description here" /></a></p>
<p>I've implemented quantization as per the above equations in python:</p>
<pre><code>b = 128
embedding_matrix = [[20000,3000,1000],[1999999,20000,1999999], [20000,3000,1000]]
scaled = [ abs(round( (1 / (b - 1) * max(e)) , 3)) for e in embedding_matrix]
print(scaled)
i = 0
quantized = []
for e in embedding_matrix :
for v in e :
quantized.append((v , math.floor(.5 + ( (v / scaled[i]) + b) )))
i = i + 1
quantized
</code></pre>
<p>Running this code <code>quantized</code> is set to :</p>
<pre><code>[(20000, 255),
(3000, 147),
(1000, 134),
(1999999, 255),
(20000, 129),
(1999999, 255),
(20000, 255),
(3000, 147),
(1000, 134)]
</code></pre>
<p>How to de-quantize back to the original values prior to quantization ?</p>
<p>Reading <a href="https://www.tensorflow.org/api_docs/python/tf/quantization/dequantize" rel="nofollow noreferrer">https://www.tensorflow.org/api_docs/python/tf/quantization/dequantize</a> describes :</p>
<pre><code>tf.quantization.dequantize(
input, min_range, max_range, mode='MIN_COMBINED', name=None, axis=None,
narrow_range=False, dtype=tf.dtypes.float32
)
[min_range, max_range] are scalar floats that specify the range for the output. The 'mode' attribute controls exactly which calculations are used to convert the float values to their quantized equivalents.
</code></pre>
<p>and the PyTorch docs: <a href="https://pytorch.org/docs/stable/quantization.html" rel="nofollow noreferrer">https://pytorch.org/docs/stable/quantization.html</a></p>
<p>Seems to implement quantize differently to above implementation ?</p>
|
<p>What they are doing in the paper is roughly this:</p>
<pre><code>import numpy as np
b = 128
embedding_matrix = np.array([[20000,3000,1000,1000],[1999999,20000,1999999,1999999], [20000,3000,1000,1000]])
scales = (np.abs(embedding_matrix).max(axis=1) / (b-1)).reshape(-1, 1)
quantized = (embedding_matrix / scales + b + 0.5).astype(np.uint8)
dequantized = (quantized - b) * scales
print(quantized)
print(dequantized)
</code></pre>
<p>Output:</p>
<pre><code>[[255 147 134 134]
[255 129 255 255]
[255 147 134 134]]
[[2.00000000e+04 2.99212598e+03 9.44881890e+02 9.44881890e+02]
[1.99999900e+06 1.57480236e+04 1.99999900e+06 1.99999900e+06]
[2.00000000e+04 2.99212598e+03 9.44881890e+02 9.44881890e+02]]
</code></pre>
<p>In short they just have <code>q_ij = round(e_ij / s_i + b)</code>, so after you just have quantized value <code>q_ij</code> your best approximation is to say that <code>q_ij = dequantized_ij / s_i + b</code>, so <code>dequantized_ij = (q_ij - b) * s_i</code></p>
<p>As to pytorch - similar functionality is available with <code>torch.quantize_per_channel</code> e.g the following code is doing pretty much the same:</p>
<pre><code>import torch
t = torch.tensor(embedding_matrix, dtype=torch.float32)
zero_point = torch.tensor([b]).repeat(t.shape[0], 1).reshape(-1)
quantized_tensor = torch.quantize_per_channel(t, t.abs().max(axis=1)[0] / (b-1), zero_point, 0, torch.quint8)
print(quantized_tensor)
print(quantized_tensor.int_repr())
</code></pre>
<p>Output:</p>
<pre><code>tensor([[2.0000e+04, 2.9921e+03, 9.4488e+02, 9.4488e+02],
[2.0000e+06, 1.5748e+04, 2.0000e+06, 2.0000e+06],
[2.0000e+04, 2.9921e+03, 9.4488e+02, 9.4488e+02]], size=(3, 4),
dtype=torch.quint8, quantization_scheme=torch.per_channel_affine,
scale=tensor([ 157.4803, 15748.0234, 157.4803], dtype=torch.float64),
zero_point=tensor([128, 128, 128]), axis=0)
tensor([[255, 147, 134, 134],
[255, 129, 255, 255],
[255, 147, 134, 134]], dtype=torch.uint8)
</code></pre>
<p>If quantized per channel like this in pytorch you can only apply <code>.dequantize()</code> on the full tensor rather then the sliced which wouldn't be a good thing for embeddings, but you can do it manually very easy using <code>repr_int</code>, <code>q_per_channel_zero_points</code>, and <code>q_per_channel_scales</code>.</p>
<p>Does this answer your question?</p>
| 1,480
|
implement quantization
|
Implementing custom h264 quantization for Ffmpeg?
|
https://stackoverflow.com/questions/42492862/implementing-custom-h264-quantization-for-ffmpeg
|
<p>I have a Raspberry Pi, and I'm livestreaming using FFmpeg. Unfortunately my wifi signal varies over the course of my stream. I'm currently using raspivid to send h264 encoded video to the stream. I have set a constant resolution and FPS, but have not set bitrate nor quantization, so they are variable.</p>
<p>However, the issue is that the quantization doesn't vary enough for my needs. If my wifi signal drops, my ffmpeg streaming speed will dip below 1.0x to 0.95xish for minutes, but my bitrate drops so slowly that ffmpeg can never make it back to 1.0x. As a result my stream will run into problems and start buffering.</p>
<p>I would like the following to happen:
If Ffmpeg (my stream command)'s reported speed goes below 1.0x (slower than realtime streaming), then increase quantization compression (lower bitrate) exponentially until Ffmpeg speed stabilizes at 1.0x. Prioritize stabilizing at 1.0x as quickly as possible. </p>
<p>My understanding is that the quantization logic Ffmpeg is using should be in the h264 encoder, but I can't find any mention of quantization at all in this github: <a href="https://github.com/cisco/openh264" rel="nofollow noreferrer">https://github.com/cisco/openh264</a>
My knowledge of h264 is almost zilch, so I'm trying to figure out</p>
<p>A) How does h264 currently vary the quantization during my stream, if at all? </p>
<p>B) Where is that code? </p>
<p>C) How hard is it for me to implement what I'm describing?</p>
<p>Thanks in advance!!</p>
| 1,481
|
|
implement quantization
|
Matlab: Help in implementing quantized time series
|
https://stackoverflow.com/questions/28734781/matlab-help-in-implementing-quantized-time-series
|
<p>I am having trouble implementing this code due to the variable <code>s_k</code> being logical 0/1. In what way can I implement this statement?</p>
<p><img src="https://latex.codecogs.com/png.latex?x%28t%29%20%3D%20%5Csum_%7Bk%3Dt%7D%5E%7Bt+N-1%7D%20s_k%202%5E%7B-%28k-n+1%29%7D" alt=""></p>
<p><code>s_k</code> is a random sequence of <code>0/1</code> generated using a <code>rand()</code> and quantizing the output of <code>rand()</code> by its mean given below. After this, I don't know how to implement. Please help.</p>
<pre><code> N =1000;
input = randn(N);
s = (input>=0.5); %converting into logical 0/1;
</code></pre>
<p><strong>UPDATE</strong> </p>
<pre><code>N = 3;
tmax = 5;
y(1) = 0.1;
for i =1 : tmax+N-1 %// Change here
y(i+1) = 4*y(i)*(1-y(i)); %nonlinear model for generating the input to Autoregressive model
end
s = (y>=0.5);
ind = bsxfun(@plus, (0:tmax), (0:N-1).');
x = sum(s(ind+1).*(2.^(-ind+N+1))); % The output of this conversion should be real numbers
% Autoregressive model of order 1
z(1) =0;
for j =2 : N
z(j) = 0.195 *z(j-1) + x(j);
end
</code></pre>
|
<p>You've generated the random <code>logical</code> sequence, which is great. You also need to know <code>N</code>, which is the total number of points to collect at one time, as well as a list of time values <code>t</code>. Because this is a discrete summation, I'm going to assume the values of <code>t</code> are discrete. What you need to do first is generate a sliding window matrix. Each column of this matrix represents a set of time values for each value of <code>t</code> for the output. This can easily be achieved with <a href="http://www.mathworks.com/help/matlab/ref/bsxfun.html" rel="nofollow"><code>bsxfun</code></a>. Assuming a maximum time of <code>tmax</code>, a starting time of <code>0</code> and a neighbourhood size <code>N</code> (like in your equation), we can do:</p>
<pre><code>ind = bsxfun(@plus, (0:tmax), (0:N-1).');
</code></pre>
<p>For example, assuming <code>tmax = 5</code> and <code>N = 3</code>, we get:</p>
<pre><code>ind =
0 1 2 3 4 5
1 2 3 4 5 6
2 3 4 5 6 7
</code></pre>
<p>Each column represents a time that we want to calculate the output at and every row in a column shows a list of time values we want to calculate for the desired output.</p>
<p>Finally, to calculate the output <code>x</code>, you simply take your <code>s_k</code> vector, make it a column vector, use <code>ind</code> to access into it, do a point-by-point multiplication with <code>2^(-k+N+1)</code> by substituting <code>k</code> with what we got from <code>ind</code>, and sum along the rows. So:</p>
<pre><code>s = rand(max(ind(:))+1, 1) >= 0.5;
x = sum(s(ind+1).*(2.^(-ind+N+1)));
</code></pre>
<p>The first statement generates a random vector that is as long as the maximum time value that we have. Once we have this, we use <code>ind</code> to index into this random vector so that we can generate a sliding window of <code>logical</code> values. We need to offset this by 1 as MATLAB starts indexing at 1.</p>
| 1,482
|
implement quantization
|
Quantized Neural Network Support is gone in TensorFlow 1.0v?
|
https://stackoverflow.com/questions/43003778/quantized-neural-network-support-is-gone-in-tensorflow-1-0v
|
<p>I'm trying to implement <strong>quantization in neural network</strong> with tensorflow r1.0 and is not working i.e. Bazel BUILD files doesn't find targets and some other files.</p>
<p>I realize that in the version <a href="https://github.com/tensorflow/tensorflow/tree/r0.9/tensorflow/contrib/quantization" rel="nofollow noreferrer">r0.9</a> the quantization folder in "contrib" is more complete than in <a href="https://github.com/tensorflow/tensorflow/tree/r1.0/tensorflow/contrib/quantization" rel="nofollow noreferrer">r1.0</a>
In fact there is no quantized operator defined in r1.0.</p>
<p><strong>There are quantization support only in r0.x versions?</strong></p>
<p>If there are somebody working with this to give an advice i will be so grateful.</p>
<p>Best regards!</p>
| 1,483
|
|
implement quantization
|
Is it possible to perform quantization on densenet169 and how?
|
https://stackoverflow.com/questions/74612146/is-it-possible-to-perform-quantization-on-densenet169-and-how
|
<p>I have been trying to performing quantization on a densenet model without success. I have been trying to implement pytorch post training static quantization. Pytorch has quantized versions of other models, but does not have for densenet. Is it possible to quantize the densenet architecture.</p>
<p>I have searched for tutorials on how to apply quantization on pre-trained models but i havent had any success.</p>
|
<p>Here's how to do this on DenseNet169 from torchvision:</p>
<pre class="lang-py prettyprint-override"><code>from torch.ao.quantization import QuantStub, DeQuantStub
from torch import nn
from torchvision.models import densenet169, DenseNet169_Weights
from tqdm import tqdm
from torch.ao.quantization import HistogramObserver, PerChannelMinMaxObserver
import torch
# Wrap base model with quant/dequant stub
class QuantizedDenseNet169(nn.Module):
def __init__(self):
super().__init__()
self.dn = densenet169(weights=DenseNet169_Weights.IMAGENET1K_V1)
self.quant = QuantStub()
self.dequant = DeQuantStub()
def forward(self, x):
x = self.quant(x)
x = self.dn(x)
return self.dequant(x)
dn = QuantizedDenseNet169()
# move to gpu
dn.cuda()
# Propagate qconfig
dn.qconfig = torch.quantization.QConfig(
activation=HistogramObserver.with_args(),
weight=PerChannelMinMaxObserver.with_args(dtype=torch.qint8)
)
# fbgemm for x86 architecture
torch.backends.quantized.engine = 'fbgemm'
dn = torch.quantization.prepare(dn, inplace=False)
# calibrate with own dataset (I'm using random inputs to show process)
with torch.no_grad():
for _ in tqdm(range(5), desc="PTQ progess"):
input_ = torch.randn([1, 3, 128, 128], device='cuda')
dn.forward(input_)
# move to cpu before quantization
dn.cpu()
dn = torch.quantization.convert(dn, inplace=False)
# check if it's working
out = dn(torch.randn([1, 3, 128, 128]))
</code></pre>
| 1,484
|
implement quantization
|
How to do quantization in JPEG compression?
|
https://stackoverflow.com/questions/44427748/how-to-do-quantization-in-jpeg-compression
|
<p>I am studying on the JPEG compression algorithm. I followed some simple version instruction to implement it in MatLab and I stuck at the quantization process.</p>
<p>So in JPEG, I use 8x8 blocks as a unit to perform the forward transform then quantize each block based on a quantization matrix (or divide by a number N for simplicity, in the instruction).</p>
<p>I implemented the DCT by myself and it works just like the built-in dct2 so I think there is no problem in my DCT code.</p>
<pre><code>function transformed_matrix = dctTransform(block, inverse)
m_size = size(block, 1);
A = zeros(m_size);
for i = 0:m_size - 1
for j = 0:m_size - 1
if i == 0
a = sqrt(1 / m_size);
else
a = sqrt(2 / m_size);
end
A(i + 1, j + 1) = a * cos(pi * (j + 0.5) * i / m_size);
end
end
if inverse == true
transformed_matrix = A' * block * A;
else
transformed_matrix = A * block * A';
end
end
</code></pre>
<p>Then I start my quantization implementation, I have done a simple version looks like below (Just for grayscale now..):</p>
<pre><code>function quantized_matrix = quantize(block, quality, inverse, mode)
m_size = size(block, 1);
N = 16;
DEFAULT_QUANTIZATION_MATRIX = ...
[16 11 10 16 24 40 51 61
12 12 14 19 26 58 60 55
14 13 16 24 40 57 69 56
14 17 22 29 51 87 80 62
18 22 37 56 68 109 103 77
24 35 55 64 81 104 113 92
49 64 78 87 103 121 120 101
72 92 95 98 112 100 103 99] * quality;
% check for input size and mode
if strcmp(mode, 'default') && m_size == 8
if inverse == true
quantized_matrix = block .* DEFAULT_QUANTIZATION_MATRIX;
else
quantized_matrix = round(block ./ DEFAULT_QUANTIZATION_MATRIX);
end
else
if inverse == true
quantized_matrix = block * N;
else
quantized_matrix = round(block / N);
end
end
end
</code></pre>
<p>My main program code is</p>
<pre><code>I = im2double(imread('../images/lena.bmp'));
block_size = 8;
fun = @(block_struct) quantize(dctTransform(block_struct.data, false), 1, false, 'defualt')
fun2 = @(block_struct) dctTransform(block_struct.data, false)
fun3 = @(block_struct) dct2(block_struct.data)
I2 = blockproc(I, [block_size block_size], fun2);
I3 = blockproc(I, [block_size block_size], fun3);
I4 = blockproc(I, [block_size block_size], fun);
subplot(2,2,1), imshow(I, []), title('The Original Image');
subplot(2,2,2), imshow(I2, []), title('The DCT Image');
subplot(2,2,3), imshow(I3, []), title('The builtin DCT Image');
subplot(2,2,4), imshow(I4, []), title('The Quantized Image');
</code></pre>
<p><a href="https://i.sstatic.net/EvS8l.png" rel="nofollow noreferrer"><img src="https://i.sstatic.net/EvS8l.png" alt="Result"></a></p>
<p>There is no difference between my DCT and the built-in DCT implementation so I think there must be something wrong with my quantization implementation. I have checked the result from the DCT computation, most of the numbers in the matrix are very small, and that is why I finally have a black image (all rounded to 0). Is there any misunderstanding of JPEG compression from my implementation? </p>
<p>Any help is appreciated.</p>
|
<p>OK, I have figured it out.</p>
<p>The problem is not about the algorithm and my DCT/Quantization implementation. </p>
<p>The problem is I am using im2double to convert my image.
From the MatLab official documentation,</p>
<blockquote>
<p>I2 = im2double(I) converts the intensity image I to double precision,
rescaling the data if necessary.</p>
</blockquote>
<p>So after <code>I = im2double(imread('../images/lena.bmp'));</code>
I actually got a scaled image, therefore the pixel values are very small (between 0 and 1). </p>
<p>I just switched to </p>
<p><code>I = double(imread('../images/lena.bmp'));</code></p>
| 1,485
|
implement quantization
|
having trouble when implementing the interface 'Quantizer' and 'Drawer' of GIF
|
https://stackoverflow.com/questions/70474890/having-trouble-when-implementing-the-interface-quantizer-and-drawer-of-gif
|
<p>In <code>image/draw</code>, <code>Quantizer</code> and <code>Drawer</code> are defined like this:</p>
<pre class="lang-golang prettyprint-override"><code>type Quantizer interface {
Quantize(p color.Palette, m image.Image) color.Palette
}
type Drawer interface {
Draw(dst Image, r image.Rectangle, src image.Image, sp image.Point)
}
</code></pre>
<p>And there are codes in <code>gif.Encode(w io.Writer, m image.Image, o *Options)</code> like this:</p>
<pre class="lang-golang prettyprint-override"><code>if opts.Quantizer != nil {
pm.Palette = opts.Quantizer.Quantize(make(color.Palette, 0, opts.NumColors), m)
}
opts.Drawer.Draw(pm, b, m, b.Min)
</code></pre>
<p>When I want to write an image quantization algorithm myself, I need to implement <code>draw.Quantizer</code> and <code>draw.Drawer</code>.</p>
<p>As you see, <code>opts.Quantizer.Quantize</code> returns the <code>Palette</code>. But actually, when calling <code>opts.Drawer.Draw</code>, I need not only the <code>Palette</code>, but also some other data from <code>Quantize</code>.</p>
<p>Is it possible to make the quantization data able to be used?</p>
<hr />
<p>Edited on 25 Dec.</p>
<p>For example, I get an indexing map when <code>quantize</code>. When I <code>draw</code>, I need this indexing map to make my algorithm faster. What can I do to pass this indexing map into the <code>Drawer</code>?</p>
|
<pre class="lang-golang prettyprint-override"><code>type quantizer struct {
indexingMap *IndexingMap
}
func (q *quantizer) Quantize(p color.Palette, img image.Image) color.Palette {
// do sth
// q.indexingMap = sth
}
type drawer struct {
q *quantizer
}
func (d drawer) Draw(dstOri draw.Image, rect image.Rectangle, src image.Image, sp image.Point) {
// do sth with d.q.indexingMap
}
func Opt() *gif.Options {
q := &quantizer{}
return &gif.Options{
NumColors: 256,
Quantizer: q,
Drawer: drawer{q: q},
}
}
</code></pre>
<p>Then I can use these quantization data in <code>Draw</code> method.</p>
| 1,486
|
implement quantization
|
Quantization scheme for Convolutional Neural Network 8-bit quantization in tensorflow
|
https://stackoverflow.com/questions/60872726/quantization-scheme-for-convolutional-neural-network-8-bit-quantization-in-tenso
|
<p><a href="https://i.sstatic.net/4R18J.png" rel="nofollow noreferrer">Tensorflow code for quantization</a>
From all the papars i have reffered for CNN quantization the quantization scheme is stated as </p>
<p>step size = range/255 for 8-bit here range = xmax-xmin
but as shown in the image in the tensorflow implementation </p>
<p>range is given by range = std::max(std::abs(*min_value), std::abs(*max_value));</p>
<p>CAN ANY ONE TELL ME THE DIFFERENCE OR PURPOSE</p>
|
<p>This is because the code you are pointing to is for symmetric quantization where the range needs to be the same on both sides of 0. So the "range" variable in that code really refers to half of the entire floating point range.</p>
<p>for instance, min_value = -1 max_value = 2</p>
<p>range = std::max(abs(-1), abs(2)) = 2</p>
<p>So the entire range in that code will be -2 to 2.</p>
<p>Hope that makes sense!</p>
| 1,487
|
implement quantization
|
Different results between quantized TFlite model to its implementation using Numpy
|
https://stackoverflow.com/questions/64410930/different-results-between-quantized-tflite-model-to-its-implementation-using-num
|
<p>I am working with Tensorflow/Keras and want to quantize model parameters and then implement the model with Numpy.
I've build 1D CNN model ,train it, then quantize its parameters , to UINT8 ,using Tensorflow post training quantization , then i've extract the weights and biases and export it to .npy file.
After build the same 1D CNN using Numpy (dtype UINT8) , with the extracted weights and biases , i check the results layer by layer and got different results compare to the quntized model results.
when i compare the results of my Numpy implementation for Floating point model ( without quantization to UINT8) i do get the same outputs as Keras model outputs.( so i guess my Numpy model is working well :) ).</p>
<p>As far as i understood , interpreter.get_input_details() include the quantization scale and zero point parameters of the input tensor which required in case i want to convert the UINT8 weights to float - am i right?</p>
<p>I will bevery happy to suggestion how to get the same results as quantized Keras model</p>
| 1,488
|
|
implement quantization
|
Can libtorch be used for quantization-aware training of models?
|
https://stackoverflow.com/questions/75886648/can-libtorch-be-used-for-quantization-aware-training-of-models
|
<p>We want to use C++ to develop a software for deep learning model training and quantification. For the convenience of deployment, we don't want to use python language, so we want to implement it based on libtorch.
I found the following example program for python-based quantization-aware training in pytorch's blog.</p>
<pre><code>import torch
from torch import nn
backend = "fbgemm" # running on a x86 CPU. Use "qnnpack" if running on ARM.
m = nn.Sequential(
nn.Conv2d(2,64,8),
nn.ReLU(),
nn.Conv2d(64, 128, 8),
nn.ReLU()
)
"""Fuse"""
torch.quantization.fuse_modules(m, ['0','1'], inplace=True) # fuse first Conv-ReLU pair
torch.quantization.fuse_modules(m, ['2','3'], inplace=True) # fuse second Conv-ReLU pair
"""Insert stubs"""
m = nn.Sequential(torch.quantization.QuantStub(),
*m,
torch.quantization.DeQuantStub())
"""Prepare"""
m.train()
m.qconfig = torch.quantization.get_default_qconfig(backend)
torch.quantization.prepare_qat(m, inplace=True)
"""Training Loop"""
n_epochs = 10
opt = torch.optim.SGD(m.parameters(), lr=0.1)
loss_fn = lambda out, tgt: torch.pow(tgt-out, 2).mean()
for epoch in range(n_epochs):
x = torch.rand(10,2,24,24)
out = m(x)
loss = loss_fn(out, torch.rand_like(out))
opt.zero_grad()
loss.backward()
opt.step()
"""Convert"""
m.eval()
torch.quantization.convert(m, inplace=True)
</code></pre>
<p>However, I did not find an example of quantization-aware training of models based on libtorch on the Internet.</p>
<p>I tried to refer to the quantization module in libtorch, but it was also wrong, as shown in the figure below.
<a href="https://i.sstatic.net/iWvIo.png" rel="nofollow noreferrer">enter image description here</a></p>
<p>Does libtorch support quantization-aware training of models, and if so, are there any relevant examples?</p>
| 1,489
|
|
implement quantization
|
Scalar vs Vector signal Quantization
|
https://stackoverflow.com/questions/70596552/scalar-vs-vector-signal-quantization
|
<p>I am studying about scalar vs vector quantization, and I have an assignment to implement (in MATLAB) a scalar quantizer , using the Lloyd-Max algorithm, and a vector quantizer via k-means clustering.</p>
<p>The <strong>vector</strong> quantizer works in the R<sup>2</sup> vector space, so its input is a tuple of samples (input vector) and its output is also a two dimensional vector, corresponding to the centroid vector of the quantization region.</p>
<p>I am told that in order for the comparisons between the two quantizers to be accurate, I need to keep the <em>number of bits per sample</em>, <strong>constant</strong>. For example, in a <strong>n-bit scalar</strong> quantizer, there are 2<sup>n</sup> quantization regions, in one of which, a sample will get quantized into.</p>
<p>The equivalent <strong>vector</strong> quantizer, will have <strong>2n</strong> bits per input tuple, so that each sample is still represented by <strong>n</strong> bits.
So, with that logic, I think that the <strong>vector</strong> quantizer should have 2<sup>2n</sup> quantization/Voronoi regions.</p>
<p>I have to quantize an equal number of samples from a Gaussian source (source <strong>A</strong>), and from an AR(5) Random process (source <strong>B</strong>). From what I've studied, I think that the <strong>scalar</strong> quantizer is expected to perform a better quantization of source <strong>A</strong> (in the MSE-sense) and the <strong>vector</strong> quantizer should perform better in the AR process (source <strong>B</strong>), where the samples are correlated with each other.</p>
<p>However, when I quantize both of the forementioned sources, and compute the MSE between the original and the quantized signal, the vector quantizer gives a smaller MSE for both sources. So the vector quantizer, is more efficient (in the MSE-sense) for both the sources, which I think is wrong, as it should be more efficient only for the Autoregressive Random process and not for the Gaussian source, as well.</p>
<p>(I calculate the MSE as :<code>mse(input_signal - quantized_signal)</code>, so there's nothing wrong there.)</p>
<p>So my questions are:</p>
<ol>
<li>Should (theoretically) the vector quantizer be more efficient in quantizing both the sources or only in the case of the AR process?</li>
<li>The <strong>vector</strong> quantizer equivalent of a <strong>n-bit scalar</strong> quantizer, should have <strong>2n</strong> or <strong>2<sup>2n</sup></strong> quantization/Voronoi regions (second argument/cluster number of kmeans() ).</li>
</ol>
<p>If needed I will post the MATLAB code, as well.</p>
<p>Any help will be greatly appreciated, as I am stuck on this for some days.</p>
<p>Thanks in advance .</p>
|
<p>K-Means is very similar to Lloyd Max algorithm.<br />
Since you give it <code>x2</code> more bits there is no wonders it performs better.</p>
| 1,490
|
implement quantization
|
How pytorch implement forward for a quantized linear layer?
|
https://stackoverflow.com/questions/72101712/how-pytorch-implement-forward-for-a-quantized-linear-layer
|
<p>I have a quantized model in pytorch and now I want to extract the parameter of the quantized linear layer and implement the forward manually.
I search the source code but only find this function.</p>
<pre><code>def forward(self, x: torch.Tensor) -> torch.Tensor:
return torch.ops.quantized.linear(
x, self._packed_params._packed_params, self.scale, self.zero_point)
</code></pre>
<p>But no where I can find how torch.ops.quantized.linear is defined.</p>
<p>Can someone give me a hind how the forward of quantized linear are defined?</p>
|
<p>In answer to the question of where <code>torch.ops.quantized.linear</code> is, I was looking for the same thing but was never able to find it. I believe it's probably somewhere in the <code>aten</code> (C++ namespace). I did, however, find some useful PyTorch-based implementations in the NVIDIA TensorRT repo below. It's quite possible these are the ones actually called by PyTorch via some DLLs. If you're trying to add quantization to a custom layer, these implementations walk you through it.</p>
<p>You can find the <a href="https://docs.nvidia.com/deeplearning/tensorrt/pytorch-quantization-toolkit/docs/index.html" rel="nofollow noreferrer">docs here</a> and the <a href="https://github.com/NVIDIA/TensorRT/tree/main/tools/pytorch-quantization" rel="nofollow noreferrer">GitHub page here</a>.</p>
<p>For the linear layer specifically, see the <a href="https://github.com/NVIDIA/TensorRT/blob/87f3394404ff9f9ec92c906cd4c39b5562aea42e/tools/pytorch-quantization/pytorch_quantization/nn/modules/quant_linear.py#L29" rel="nofollow noreferrer">QuantLinear layer here</a></p>
<p>Under the hood, this calls <a href="https://github.com/NVIDIA/TensorRT/blob/87f3394404ff9f9ec92c906cd4c39b5562aea42e/tools/pytorch-quantization/pytorch_quantization/tensor_quant.py#L234" rel="nofollow noreferrer">TensorQuantFunction.apply()</a> for post-training quantization or <a href="https://github.com/NVIDIA/TensorRT/blob/87f3394404ff9f9ec92c906cd4c39b5562aea42e/tools/pytorch-quantization/pytorch_quantization/tensor_quant.py#L298" rel="nofollow noreferrer">FakeTensorQuantFunction.apply()</a> for quantization-aware training.</p>
| 1,491
|
implement quantization
|
How to find float output range for quantized matmul/conv2D operation
|
https://stackoverflow.com/questions/53003155/how-to-find-float-output-range-for-quantized-matmul-conv2d-operation
|
<p>I am new to tensorflow and quantization, am trying to implement quantized matmul operation for two int8 inputs. Was curious to know the math behind the operation. I see in tensorflow they have implemented the same only for uint8 inputs , would like to know how to use that for signed int8 matmul/conv2D.</p>
<p>More precisely I would like to know how to get the float output range for the matmul/conv2D operation.</p>
<p>Any help would be highly appreciated.</p>
|
<p>I have investigated the quantization in tensorflow a bit and applied it to convert float operations into quant oeprations. </p>
<p>In my case I have still a float input to the net. The input gets quantized right before entering the quant operations. Tensorflow prefers keeping float values as long as possible in order to be compatible to float operations.
This is also the reason, why tensorflow keeps the min and max float ranges after the float input gets quantized into 8bit integer format.
The min and max float values as a result from quantization are also inputs to the quant operations.</p>
<p>In your case, the Quant_conv2d operation does a convolution with inputs: </p>
<ul>
<li>unsigned 8bit data form qunatization</li>
<li>unsigned 8bit quantized kernel values </li>
</ul>
<p>The outputs are:</p>
<ul>
<li>result as 32 bit </li>
<li>the new min and max range as float values</li>
</ul>
<p>The new float ranges are calculated from the ranges of the kernel values and the ranges of the input using the QuantizationRangeForMultiplication function stated in:</p>
<p><a href="https://github.com/tensorflow/tensorflow/blob/master/tensorflow/core/kernels/quantization_utils.h" rel="nofollow noreferrer">https://github.com/tensorflow/tensorflow/blob/master/tensorflow/core/kernels/quantization_utils.h</a></p>
<p>As stated, the output is a 32 bit with min and max float values to map to the absolute values and possbily convert the 8bit quantized format back to float.</p>
<p>Hope this helps to understand Tensorflow quantization algorithms.</p>
| 1,492
|
implement quantization
|
Image Dithering: How would I calculate quantization error and nearest colour to implement in a Floyd-Steinburg algorithm?
|
https://stackoverflow.com/questions/3867581/image-dithering-how-would-i-calculate-quantization-error-and-nearest-colour-to
|
<p>I intend to display (4, 8 or 16 bit per channel - no alpha) images on a 1 bit display in an embedded system. Images are stored in RGB tuples. My intention is to use Floyd-Steinburg, as it looks reasonably good, is more than quick enough and concise in code.</p>
<p>In reference to the WikiPedia <a href="http://en.wikipedia.org/wiki/Floyd%E2%80%93Steinberg_dithering" rel="nofollow">article</a>, I have two questions.</p>
<p><strong>What would the best practice for expressing nearest colour be?</strong> Would the following work? (ignore that I'm returning a structure in c)</p>
<pre><code>typedef rgb16_tag { unsigned short r, g, b } rgb16;
rgb16 nearest_1bit_colour(rgb16 p) {
double c; rgb16 r;
c = ((double)(p.r + p.g + p.b + 3 * (1 << 15))) / ( 3.0 * (1 << 16));
if (c>= 1.0) {
r.r = r.g = r.b = 1;
} else {
r.r = r.g = r.b = 0;
}
return r;
}
</code></pre>
<p>and, <strong>Is the expression of quantization error done on a per channel basis?</strong> i.e. does this make sense?</p>
<pre><code>rgb16 q, new, old, image[X][Y];
int x, y;
... /* (somewhere in the nested loops) */
old = image[x][y];
new = nearest_1bit_colour(old);
/* Repeat the following for each colour channel seperately. */
q.{r,g,b} = old.{r,g,b} - new.{r,g,b};
image[x+1][y].{r,g,b} = image[x+1][y].{r,g,b} + 7/16 * q.{r,g,b}
image[x-1][y+1].{r,g,b} = image[x-1][y+1].{r,g,b} + 3/16 * q.{r,g,b}
image[x][y+1].{r,g,b} = image[x][y+1].{r,g,b} + 5/16 * q.{r,g,b}
image[x+1][y+1].{r,g,b} = image[x+1][y+1].{r,g,b} + 1/16 * q.{r,g,b}
</code></pre>
|
<p>I've seen two typical approaches to measuring the difference between two colors. The most common way is probably to just find the Euclidian distance between them through the color cube:</p>
<pre><code>float r = i.r - j.r;
float g = i.g - j.g;
float b = i.b - j.b;
float diff = sqrtf( r * r + g + g + b * b );
</code></pre>
<p>The other is just to average the absolute differences, possibly weighting for luminance:</p>
<pre><code>float diff = 0.30f * fabs( i.r - j.r ) +
0.59f * fabs( i.g - j.g ) +
0.11f * fabs( i.b - j.b );
</code></pre>
<p>As to your second question, yes. Accumulate the error separately in each channel.</p>
<p><b>Edit</b>: Misread at first and missed that this was for a bi-level display. In that case, I'd suggest just using luminance:</p>
<pre><code>float luminance = 0.30f * p.r + 0.59f * p.g + 0.11f * p.b;
if ( luminance > 0.5f * channelMax ) {
// white
} else {
// black
}
</code></pre>
| 1,493
|
implement quantization
|
Issues with MP3-like Compression: Quantization and File Size
|
https://stackoverflow.com/questions/79333155/issues-with-mp3-like-compression-quantization-and-file-size
|
<p>I’m trying to implement an MP3-like compression algorithm for audio and have followed the general steps, but I’m encountering a few issues with the quantization step. Here's the overall process I'm following:</p>
<ol>
<li>Apply Hanning window to the audio</li>
<li>Apply a filter bank (mp3_forward_fbt).</li>
<li>Apply Discrete Cosine Transform (DCT).</li>
<li>Quantize the DCT coefficients.</li>
<li>Apply Inverse Discrete Cosine Transform (IDCT).</li>
<li>Apply the inverse filter bank (mp3_reverse_fbt).</li>
</ol>
<p>The process works fine, but I’m running into problems during the quantization step. When I remove any number of coefficients (to reduce data), the audio quality degrades significantly. I’ve also tried converting the coefficient array from float to int32 or int16, but the output file size remains the same as the input file size.</p>
<p>I’m looking for insights into what I might be missing or suggestions on how to improve quantization and file size reduction. Here is the code I’m using:</p>
<pre><code>import os
import numpy as np
import scipy.io.wavfile as wav
from scipy.fftpack import dct, idct
import mp3funcs as mp
file_path = os.path.abspath('Projekt_1/audio.wav')
fs, audio = wav.read(file_path)
left_audio = audio[:, 0]
right_audio = audio[:, 1]
window_size = 512
hop_size = window_size // 2
hanning_window = np.hanning(window_size)
def apply_hanning(audio):
num_frames = (len(audio) - window_size) // hop_size + 1
windowed_audio = np.zeros(len(audio), dtype=np.float64)
for i in range(num_frames):
start = i * hop_size
end = start + window_size
windowed_audio[start:end] += audio[start:end] * hanning_window
return windowed_audio
left_audio = apply_hanning(left_audio)
right_audio = apply_hanning(right_audio)
left_audio = mp.mp3_forward_fbt(left_audio)
right_audio = mp.mp3_forward_fbt(right_audio)
left_dct = dct(left_audio, type=2, n=None, axis=-1, norm='ortho')
right_dct = dct(right_audio, type=2, n=None, axis=-1, norm='ortho')
# quantization here
left_quant = []
right_quant = []
padding_needed_left = (32 - (len(left_quant) % 32)) % 32
left_quant = np.pad(left_quant, (0, padding_needed_left), mode='constant')
padding_needed_right = (32 - (len(right_quant) % 32)) % 32
right_quant = np.pad(right_quant, (0, padding_needed_right), mode='constant')
left_audio = idct(left_quant, type=2, n=None, axis=-1, norm='ortho')
right_audio = idct(right_quant, type=2, n=None, axis=-1, norm='ortho')
left_audio = mp.mp3_reverse_fbt(left_audio)
right_audio = mp.mp3_reverse_fbt(right_audio)
min_length = min(len(left_audio), len(right_audio))
left_audio = left_audio[:min_length]
right_audio = right_audio[:min_length]
audio = np.column_stack((left_audio, right_audio))
output_file_path = 'Projekt_1/output.wav'
wav.write(output_file_path, fs, audio.astype(np.int16))
# Test
print("Size difference:", os.path.getsize(output_file_path) - os.path.getsize(file_path))
</code></pre>
| 1,494
|
|
implement quantization
|
Color quantization: Same as detecting color palette?
|
https://stackoverflow.com/questions/53976162/color-quantization-same-as-detecting-color-palette
|
<p>I'm interested in implementing a tool similar to <a href="https://www.canva.com/color-palette/" rel="nofollow noreferrer">Canva's Palette tool</a>, with the final goal of production CSS UI colors from an image (similar to how Spotify determines UI colors based on album art). </p>
<p>I've read about <a href="http://www.cubic.org/docs/octree.htm" rel="nofollow noreferrer">color quantization using the octree data type</a>. But I'm wondering if this will lead me to the solution, or if octree quantization is simply for compression.</p>
<p>Any help towards my goal is greatly appreciated! </p>
|
<p>There are many ways to find an image's <a href="https://peteroupc.github.io/colorgen.html#Dominant_Colors_of_an_Image" rel="nofollow noreferrer">dominant colors</a>. These include not only octrees but also k-means clustering, histograms, and posterization. Some of them can indeed be used to find an image's color palette, if we treat the problem as finding not just one dominant color, but <em>the N dominant colors</em> of that image.</p>
<p>You should implement octrees or another dominant-color-finding method first and see whether that implementation suits your purposes, then ask other questions on this site if you have further issues.</p>
| 1,495
|
implement quantization
|
Does static quantization enable the model to feed a layer with the output of the previous one, without converting to fp (and back to int)?
|
https://stackoverflow.com/questions/78026212/does-static-quantization-enable-the-model-to-feed-a-layer-with-the-output-of-the
|
<p>I was reading about quantization (specifically abount int8) and trying to figure it out if there is a method to avoid dequantize and requantize the output of a node before feeding it to the next one. So i eventually find the definition of static and dynamic quantization. According to <a href="https://onnxruntime.ai/docs/performance/model-optimizations/quantization.html" rel="nofollow noreferrer">onnxruntime</a>:</p>
<blockquote>
<p>Dynamic quantization calculates the quantization parameters (scale and zero point) for activations dynamically. [...] Static quantization method first runs the model using a set of inputs called calibration data. During these runs, we compute the quantization parameters for each activations. These quantization parameters are written as constants to the quantized model and used for all inputs.</p>
</blockquote>
<p>To me that seem quite clear, saying that the difference between the two methods is about when (de)quantization parameters are computed (with dynamic doing it at inference time and static doing it before inference and hardcoding them in the model) and not about the actual (de)quantization process.</p>
<p>However I got in touch with some articles/forum answers which seems to point to a different direction. This <a href="https://www.philschmid.de/static-quantization-optimum" rel="nofollow noreferrer">article</a> say about static quantization:</p>
<blockquote>
<p>[...] Importantly, this additional step allows us to pass quantized values between operations instead of converting these values to floats - and then back to ints - between every operation, resulting in a significant speed-up.</p>
</blockquote>
<p>It seems to be arguing that static quantization does not require to apply dequantize and then quantize operations to the output of a node before feeding it as input to the next one.
I also found a <a href="https://discuss.pytorch.org/t/how-to-use-a-quantized-model-on-int8-harware/70605" rel="nofollow noreferrer">discussion</a> arguing the same:</p>
<blockquote>
<p>Q: [...] However, our hardware colleagues told me that because it has FP scales and zero-points in channels, the hardware should still support FP in order to implement it.
They also argued that in each internal stage, the values (in-channels) should be dequantized and converted to FP and quantized again for the next layer. [...]</p>
</blockquote>
<blockquote>
<p>A: For the first argument you are right, since scales and zero-points are FP, hardware need to support FP for the computation.
The second argument may not be true, for static quantization the output of the previous layer can be fed into next layer without dequantizing to FP. Maybe they are thinking about dynamic quantization, which keeps tensors between two layers in FP.</p>
</blockquote>
<p>And others have aswered the same.</p>
<p>So I tried out to manually quantize a model using <code>onnxruntime.quantization.quantize_static</code>. Before going on I have to make a premise: I'm not in the field of AI, and I'm learning about the topic for another purpose. So I googled to find out how to do that and I managed to get it done with the following code:</p>
<pre class="lang-py prettyprint-override"><code>import torch
import torchvision as tv
import onnxruntime
from onnxruntime import quantization
MODEL_PATH = "best480x640.onnx"
MODEL_OPTIMIZED_PATH = "best480x640_optimized.onnx"
QUANTIZED_MODEL_PATH = "best480x640_quantized.onnx"
class QuntizationDataReader(quantization.CalibrationDataReader):
def __init__(self, torch_ds, batch_size, input_name):
self.torch_dl = torch.utils.data.DataLoader(
torch_ds, batch_size=batch_size, shuffle=False)
self.input_name = input_name
self.datasize = len(self.torch_dl)
self.enum_data = iter(self.torch_dl)
def to_numpy(self, pt_tensor):
return (pt_tensor.detach().cpu().numpy() if pt_tensor.requires_grad
else pt_tensor.cpu().numpy())
def get_next(self):
batch = next(self.enum_data, None)
if batch is not None:
return {self.input_name: self.to_numpy(batch[0])}
else:
return None
def rewind(self):
self.enum_data = iter(self.torch_dl)
preprocess = tv.transforms.Compose([
tv.transforms.Resize((480, 640)),
tv.transforms.ToTensor(),
tv.transforms.Normalize(
mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
ds = tv.datasets.ImageFolder(root="./calib/", transform=preprocess)
# optimisations
quantization.shape_inference.quant_pre_process(
MODEL_PATH, MODEL_OPTIMIZED_PATH, skip_symbolic_shape=False)
quant_ops = {"ActivationSymmetric": False, "WeightSymmetric": True}
ort_sess = onnxruntime.InferenceSession(
MODEL_PATH, providers=["CPUExecutionProvider"])
qdr = QuntizationDataReader(
ds, batch_size=1, input_name=ort_sess.get_inputs()[0].name)
quantized_model = quantization.quantize_static(
model_input=MODEL_OPTIMIZED_PATH,
model_output=QUANTIZED_MODEL_PATH,
calibration_data_reader=qdr,
extra_options=quant_ops
)
</code></pre>
<p>However results confused me more. The following images show a chunk of the two models graphs (the "original" one and the quantized one) on netron.
This is the non quantized model graph.</p>
<p><a href="https://i.sstatic.net/fJoH4.png" rel="nofollow noreferrer"><img src="https://i.sstatic.net/fJoH4.png" alt="enter image description here" /></a></p>
<p>While this is the quantized one.
<a href="https://i.sstatic.net/5ebQW.png" rel="nofollow noreferrer"><img src="https://i.sstatic.net/5ebQW.png" alt="enter image description here" /></a></p>
<p>The fact that it added QuantizeLinear/DequantizeLinear nodes may indicate the answer I'm looking for. However, the way those nodes are placed makes no sense to me: it computes dequantization immediately after quantization, so the input types of various Conv, Mul, etc nodes is still float32 tensors.
I'm sure I'm missing (or misunderstanding) something here, so I can't figure out what I was originally looking for: does static quantization allow to feed a node with the still quantized output of the previous one? And what I'm getting wrong with the quantization process above?</p>
|
<p>Hardware AI guy here, I highly recommend reading my blog,
<a href="https://franciscormendes.github.io/2024/05/16/quantization-layer-details/" rel="nofollow noreferrer">https://franciscormendes.github.io/2024/05/16/quantization-layer-details/</a>
But I will summarize it here.
In short : if you want, you can pass values as int between layers as well. Consider the matrix multiplication (which is nothing but the output of a single layer in a neural network, with weights $W$ and bias $b$),</p>
<p>Y = Wx+b</p>
<p>$Y = Wx + b$</p>
<p>This can be represented as a quantized multiplication (you can find the details in the blog),</p>
<p>Option 1:</p>
<p>$$Y = S_q(X_q-Z_q)S_w(W_q-Z_w) + S_b(b_q-Z_b)$$</p>
<p>However, you can quantize the output too,</p>
<p>Option 2:
$$Y_q = \frac{S_xS_w}{S_Y}((X_q-Z_x)(W_q-Z_w)+b) + Z_Y$$</p>
<p>Remember that $\frac{S_xS_W}{S_Y}$ is constant and we know it at the time of compiling, so we can consider it to be a fixed point operation, we can write it as</p>
<p>$$M := \frac{S_xS_W}{S_Y} = 2^{-n}M_0$$ where $n$ is always a fixed number determined at the time of compilation (this is not true for floating point).
Thus the entire expression,
$$Y_q = M((X_q-Z_x)(W_q-Z_w)+b) + Z_Y$$
can be carried out with integer arithmetic and all values exchanged between layers are integer values. So if your hardware supports only INT8 you will use</p>
<p>Using the matrix multiplication example, FULL INT8 quantization essentially means you can deploy a neural network on a board that does not support ANY floating point operations. It is in fact the $Y_q$ that is passed between layers when you do INT8 quantization.</p>
<p>Option 1(a) :
$$Y_q = M_0((X_q-Z_x)(W_q-Z_w)+b) + Z_Y$$.</p>
<p>However, if you just need the weights and the multiplies to be quantized but not the activations, it means that you are getting the benefits of quantization for saving space of the weights and by using integer multiply BUT are choosing to pass values between the layers as floats. For this case, PyTorch and Keras can also spit out the floating point values, to be passed between layers, and it does this by simply omitting the quantization step, so in this case you do not need to quantize the output (Option 1)</p>
<p>$$Y = S_xS_w(X_q-Z_x)(W_q-Z_w) + S_b(b_q-Z_b)$$</p>
| 1,496
|
implement quantization
|
Fail to quantize custom layer - Quantization Aware Training
|
https://stackoverflow.com/questions/70351174/fail-to-quantize-custom-layer-quantization-aware-training
|
<p>I'm following <a href="https://www.tensorflow.org/model_optimization/guide/quantization/training_comprehensive_guide?hl=en" rel="nofollow noreferrer">Quantization aware training comprehensive guide</a> and struggling with QAT for custom layers, working with <code>tf=2.6.0</code>, <code>py=3.9.7</code>.
Below is a toy example of my problem:</p>
<p>I wrote a simple custom layer that implements Conv2D</p>
<pre><code>class MyConv(tf.keras.layers.Layer):
'''costume conv2d'''
def __init__(self, filt=1, name=None, **kwargs):
super(MyConv, self).__init__(name=name)
self.filt = filt
super(MyConv, self).__init__(**kwargs)
def get_config(self):
config = super().get_config().copy()
config.update({"filt": self.filt})
return config
def build(self, shape):
self.conv = tf.keras.layers.Conv2D(self.filt, 1, padding="same")
def call(self, input):
return self.conv(input)
</code></pre>
<p>I've created a small model with that layer, then recursively pass over its layers and annotates them using <code>tfmot.guantization.keras.quantize_annotate_layer</code> (each custom layer could have more custom sub-layers that needs to be quantized). Then I apply <code>tfmot.quantization.keras.quantize_apply</code> to the annotated model. The result model consists of all the quantized layers, except of my custom layer, that had not been quantized.</p>
<p><img src="https://i.sstatic.net/bFURD.png" alt="model summary attached" /></p>
<p>I'll note that when I'm replacing the custom layer <code>MyConv</code> with the code below, as in the comprehensive guide, the quantization works.</p>
<pre><code>def MyConv(tf.keras.layers.Conv2D):
pass
</code></pre>
<p>Please help me solve this issue. Might be some issue with my <code>QuantizeConfig</code>?</p>
<p>Below is my full code:</p>
<pre><code>import tensorflow as tf
import tensorflow_model_optimization as tfmot
class MyConv(tf.keras.layers.Layer):
'''costume conv2d'''
def __init__(self, filt=1, name=None, **kwargs):
super(MyConv, self).__init__(name=name)
self.filt = filt
super(MyConv, self).__init__(**kwargs)
def get_config(self):
config = super().get_config().copy()
config.update({"filt": self.filt})
return config
def build(self, shape):
self.conv = tfmot.quantization.keras.quantize_annotate_layer(tf.keras.layers.Conv2D(self.filt, 1, padding="same"))
def call(self, input):
return self.conv(input)
def get_toy_model():
input = tf.keras.Input((10, 10, 1), name='input')
x = tf.keras.layers.Conv2D(1, 3, padding="same")(input)
x = tf.keras.layers.ReLU()(x)
x = MyConv()(x)
for _ in range(2):
y = tf.keras.layers.Conv2D(1, 3, padding="same")(x)
y = tf.keras.layers.ReLU()(y)
out = tf.keras.layers.Conv2D(1, 3, padding="same")(y)
return tf.keras.Model(input, out, name='toy_Conv2D')
LastValueQuantizer = tfmot.quantization.keras.quantizers.LastValueQuantizer
MovingAverageQuantizer = tfmot.quantization.keras.quantizers.MovingAverageQuantizer
class DefaultCostumeQuantizeConfig(tfmot.quantization.keras.QuantizeConfig):
# Configure how to quantize weights.
def get_weights_and_quantizers(self, layer):
return []
# Configure how to quantize activations.
def get_activations_and_quantizers(self, layer):
return []
def set_quantize_weights(self, layer, quantize_weights):
pass
def set_quantize_activations(self, layer, quantize_activations):
pass
# Configure how to quantize outputs (may be equivalent to activations).
def get_output_quantizers(self, layer):
return [tfmot.quantization.keras.quantizers.MovingAverageQuantizer(num_bits=8, per_axis=False, symmetric=False, narrow_range=False)]
def get_config(self):
return {}
def recursive_depth_layers(layer):
for l in list(layer.__dict__.values()):
if isinstance(l, tf.keras.layers.Layer):
recursive_depth_layers(l)
if isinstance(l, (
tf.keras.layers.Dense, tf.keras.layers.Conv2D, tf.keras.layers.ReLU, tf.keras.layers.LeakyReLU, tf.keras.layers.Activation)):
ql = tfmot.quantization.keras.quantize_annotate_layer(l, DefaultCostumeQuantizeConfig())
ql._name += "_" + l.name
return ql
def apply_quantization(layer):
# regular layer
if isinstance(layer, (tf.keras.layers.Dense, tf.keras.layers.Conv2D, tf.keras.layers.ReLU, tf.keras.layers.LeakyReLU,tf.keras.layers.Activation)):
l = tfmot.quantization.keras.quantize_annotate_layer(layer, DefaultCostumeQuantizeConfig())
l._name += '_' + layer.name
return l
if layer.__module__ == "__main__":
# custom layer
recursive_depth_layers(layer)
l = tfmot.quantization.keras.quantize_annotate_layer(layer, DefaultCostumeQuantizeConfig())
l._name += '_' + layer.name
return l
return layer
model = get_toy_model()
model.summary()
annotated_model = tf.keras.models.clone_model(model, clone_function=apply_quantization)
annotated_model.summary()
quantize_scope = tfmot.quantization.keras.quantize_scope
with quantize_scope({'DefaultCostumeQuantizeConfig': DefaultCostumeQuantizeConfig, 'MyConv': MyConv}):
quant_aware_model = tfmot.quantization.keras.quantize_apply(annotated_model)
quant_aware_model._name += "_quant"
quant_aware_model.summary()
quant_aware_model.compile()
</code></pre>
| 1,497
|
|
implement quantization
|
Vector quantization for categorical data
|
https://stackoverflow.com/questions/27694998/vector-quantization-for-categorical-data
|
<p>Software for vector quantization usually works only on numerical data. One example of this is Python's <code>scipy.cluster.vq.vq</code> (<a href="http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.cluster.vq.vq.html#scipy.cluster.vq.vq" rel="nofollow">here</a>), which performs vector quantization. The numerical data requirement also shows up for most clustering software.</p>
<p>Many have pointed out that you can always convert a categorical variable to a set of binary numeric variables. But this becomes awkward when working with big data where an individual categorical variable may have hundreds or thousands of categories.</p>
<p>The obvious alternative is to change the distance function. With mixed data types, the distance from an observation to a "center" or "codebook entry" could be expressed as a two-part sum involving (a) the usual Euclidean calculation for the numeric variables and (b) the sum of inequality indicators for categorical variables, as proposed <a href="http://link.springer.com/chapter/10.1007%2F978-3-642-11819-7_10#page-1" rel="nofollow">here</a> on page 125.</p>
<p>Is there any open-source software implementation of vector quantization with such a generalized distance function? </p>
|
<p>You cannot "quantize" categorial data.</p>
<p>Recall <em>definitions</em> of quantization (<a href="https://en.wiktionary.org/wiki/quantize" rel="nofollow">Wiktionary</a>):</p>
<blockquote>
<ol>
<li>To limit the number of possible values of a quantity, or states of a system, by applying the rules of quantum mechanics</li>
<li>To approximate a <em>continuously varying</em> signal by one whose amplitude can only have a set of <em>discrete</em> values</li>
</ol>
</blockquote>
<p>In other words, quantization means <strong>converting a <em>continuous</em> variable into a <em>discrete</em> variable</strong>. Vector quantization does the same, for multiple variables at the same time.</p>
<p>However, <strong>categorial variables <em>already</em> are discrete</strong>.</p>
<p>What you seem to be looking for is a prototype-based clustering algorithm for categorial data (maybe STING and COOLCAT? I don't know if they will produce prototypes); but this isn't "vector quantization" anymore.</p>
<p>I believe that very often, <strong>frequent itemset mining</strong> is actually the best approach to find prototypes/archetypes of categorial data.</p>
<p>As for clustering algorithms that allow other distance functions - there are plenty. <a href="http://elki.dbs.ifi.lmu.de/" rel="nofollow">ELKI</a> has a lot of such algorithms, and also a <a href="http://elki.dbs.ifi.lmu.de/wiki/Tutorial/DistanceFunctions" rel="nofollow">tutorial on implementing a custom distance</a>. But this is Java, not Python. I'm pretty sure at least <em>some</em> of the clustering algorithms in scipy to allow custom distances, too.</p>
<p>Now pythons <code>scipy.cluster.vq.vq</code> is <em>really</em> simple code. You do not need a library for that at all. The main job of this function is wrapping a C implementation which runs much faster than python code... if you look at the <code>py_vq</code> version (which is used when the C version cannot be used), is is really simple code... essentially, for every object <code>obs[i]</code> it calls this function:</p>
<pre><code>code[i] = argmin(np.sum((obs[i] - code_book) ** 2, 1))
</code></pre>
<p>Now you obviously can't use Euclidean distance with a categorial codebook; but translating this line to whatever similarity you want is not hard.</p>
<p>The harder part usually is <em>constructing</em> the codebook, not using it.</p>
| 1,498
|
implement quantization
|
How to compute Quantization Error for clustering?
|
https://stackoverflow.com/questions/48178527/how-to-compute-quantization-error-for-clustering
|
<p>I would like to measure the quality of clustering using Quantization Error but can't find any clear info regarding how to compute this metric.</p>
<p>The few documents/ articles I've found are:</p>
<ul>
<li>"<em><a href="https://www.sciencedirect.com/science/article/pii/S0031320314003781" rel="nofollow noreferrer">Estimating the number of clusters in a numerical data set via quantization error modeling</a></em>" (Unfortunately there's no free access to this paper) </li>
<li><a href="https://stats.stackexchange.com/questions/9547/measuring-quantization-error-for-clustering-squared-or-not">This question</a> posted back in 2011 on Cross-Validated about the different types of distance measures (the question is very specific and doesn't give much about the calculation)</li>
<li><a href="https://gist.github.com/StuartGordonReid/7841ab6837e7e84476f3#file-clusteringobjectivefunctions-py" rel="nofollow noreferrer">This gist repo</a> where a <code>quantization_error</code> function (at the very end of the code) is implemented in Python</li>
</ul>
<p>Regarding the third link (which is the best piece of info I've found so far) I don't know how to interpret the calculation (see snippet below):</p>
<p>(the # annotations are mine. question marks indicate steps that are unclear to me)</p>
<pre><code>def quantization_error(self):
"""
This method calculates the quantization error of the given clustering
:return: the quantization error
"""
total_distance = 0.0
s = Similarity(self.e) #Class containing different types of distance measures
#For each point, compute squared fractional distance between point and centroid ?
for i in range(len(self.solution.patterns)):
total_distance += math.pow(s.fractional_distance(self.solution.patterns[i], self.solution.centroids[self.solution.solution[i]]), 2.0)
return total_distance / len(self.solution.patterns) # Divide total_distance by the total number of points ?
</code></pre>
<p>QUESTION: Is this calculation of the quantization error correct ? If no, what are the steps to compute it ?</p>
<p>Any help would be much appreciated.</p>
|
<p>At the risk of restating things you already know, I'll cover the basics.</p>
<p><strong>REVIEW</strong></p>
<p><strong>Quantization</strong> is any time we simplify a data set by moving each of the many data points to a convenient (nearest, by some metric) quantum point. These quantum points are a much smaller set. For instance, given a set of floats, rounding each one to the nearest integer is a type of quantization.</p>
<p>Clustering is a well-known, often-used type of quantization, one in which we use the data points themselves to determine the quantum points.</p>
<p><strong>Quantization error</strong> is a metric of the error introduced by moving each point from its original position to its associated quantum point. In clustering, we often measure this error as the root-mean-square error of each point (moved to the centroid of its cluster).</p>
<p><strong>YOUR SOLUTION</strong></p>
<p>... is correct, in a very common sense: you've computed the sum-squared error of the data set, and taken the mean of that. This is a perfectly valid metric.</p>
<p>The method I see more often is to take the square root of that final mean, cluster by cluster, and use the sum of those roots as the error function for the entire data set.</p>
<p><strong>THE CITED PAPER</strong></p>
<p>One common question in k-means clustering (or any clustering, for that matter), is "what is the optimum number of clusters for this data set?" The paper uses <em>another</em> level of quantization to look for a balance.</p>
<p>Given a set of <code>N</code> data points, we want to find the optimal number 'm' of clusters, which will satisfy some rationalization for "optimum clustering". Once we find <code>m</code>, we can proceed with our usual clustering algorithm to find the optimal clustering.</p>
<p>We cant' simply minimize the error at <em>all</em> cost: using <code>N</code> clusters gives us an error of 0.</p>
<p>Is that enough explanation for your needs?</p>
| 1,499
|
implement quantization
|
How can I do color quantization of images in Android?
|
https://stackoverflow.com/questions/47287777/how-can-i-do-color-quantization-of-images-in-android
|
<p>I want to reduce the color count of an image. Android provides a palette library to build palettes:
<a href="https://developer.android.com/reference/android/support/v7/graphics/Palette.Builder.html" rel="nofollow noreferrer">https://developer.android.com/reference/android/support/v7/graphics/Palette.Builder.html</a></p>
<p>But the Palette Builder only build the palette itself, but doesn't return the color mapping.</p>
<p>Is there a lower level Android library that can do color quantization? Or do I need to implement this myself?</p>
| 1,500
|
|
implement quantization
|
Set quantize factor in WIC
|
https://stackoverflow.com/questions/29269431/set-quantize-factor-in-wic
|
<p>I am trying to Replace the encoder module of a application with my own Encoder which use WIC. and the old one seems set the Quantize factor to 90 (i don't know what happen in there, i just have dlls only). Now i have to set quantize factor too but i don't know how.
is there any way to set that value like passing some value, or am i need to implement Quantize table and calculate the factor.
I sow there is a way to set image quality (which 0 to 1) when initializing the encoder,</p>
<p><code>PROPBAG2::pstrName = L"ImageQuality";</code></p>
<p>does that affect to the quantization?</p>
<p>the question looks like silly but google didn't help me. can anyone please help me.</p>
|
<blockquote>
<p>does that affect to the quantization?</p>
</blockquote>
<p>Yes. </p>
<p>that set the quality level and that decide the quintize table which use to compress.</p>
<p>normally quality level is considered as a percentage. in WIC it take float value 0-1. </p>
<p>if you want to set quality level to 90 (it probably says 90%) use 0.9f in WIC.</p>
<p>and you can set a quantize table too. </p>
<p>ref: <a href="http://fotoforensics.com/tutorial-estq.php" rel="nofollow">http://fotoforensics.com/tutorial-estq.php</a> </p>
| 1,501
|
implement quantization
|
Minimum Variance Quantization and MatLab
|
https://stackoverflow.com/questions/39842367/minimum-variance-quantization-and-matlab
|
<p>I've implemented Minimum Variance Quantization algorithm described <a href="https://imcs.dvfu.ru/lib.int/docs/Programming/Graphics/Academic%20Press%20Graphics%20Gems%20Ii%201995.pdf" rel="nofollow noreferrer">here</a> on page 126 (or 154 if you use pdf viewer search). This method is used in matlab function <code>rgb2ind</code> described <a href="https://www.mathworks.com/help/matlab/ref/rgb2ind.html" rel="nofollow noreferrer">here</a> if you specify the number of colors.
However, my implemented algorithm doesn't give the same result as this matlab function. Now I'm trying to explore matlab source code of <code>rgb2ind</code>. I found <a href="http://ecco2.jpl.nasa.gov/opendap/hyrax/matlab/images/images/rgb2ind.m" rel="nofollow noreferrer">this page</a>, by the way, the same information is available from matlab if you print <code>edit rgb2ind</code>. There's the following code:</p>
<pre><code>...
else % N is given. Use variance minimization quantization
[map,X] = cq(RGB,m);
map = double(map) / 255;
if dith(1)=='d',% Use standalone dither if map is an approximation.
X = dither(RGB,map);
end
end
</code></pre>
<p>Well, looks like the source code of Minimum Variance Quantization algorithm is hidden behind <code>cq</code> function.</p>
<p>The problem is that I can't find an implementation of this <code>cq</code> function using Google and <code>edit cq</code> command in matlab. So I need your help, StackOverFlow community. Thank You!</p>
| 1,502
|
|
implement quantization
|
How to convert the model with grid_sample to TensorRT with INT8 quantization?
|
https://stackoverflow.com/questions/69162186/how-to-convert-the-model-with-grid-sample-to-tensorrt-with-int8-quantization
|
<p>I am trying to convert the model with torch.nn.functional.grid_sample from Pytorch (1.9) to TensorRT (7) with INT8 quantization throught ONNX (opset 11).
Opset 11 does not support grid_sample conversion to ONNX. Thus I used ONNX graphsurgeon together with the external GridSamplePlugin as it is <a href="https://github.com/TrojanXu/onnxparser-trt-plugin-sample" rel="nofollow noreferrer">proposed here</a>. With it the conversion to TensorRT (both with and without INT8 quantization) is succesfull.
Pytorch and TRT model without INT8 quantization provide results close to identical ones (MSE is of e-10 order). But for TensorRT with INT8 quantization MSE is much higher (185).</p>
<p>grid_sample operator gets two inputs: the input signal and the sampling grid. Both of them should be of the same type. In the GridSamplePlugin only processing of kFLOAT and kHALF is implemented.
In my case X coordinate in the absolute sampling grid (before it is converted to the relative one required for grid_sample) is changing in the range [-d; W+d], and [-d; H+d] for Y coordinate. Maximal value of W is 640, and 360 for H. And the coordinates may have non-integer values in this range.
For the test purposes I created the test model that contains only grid_sample layer. And in this case TensorRT results with and without INT8 quantization are identical.</p>
<p>Here is the code of the test model:</p>
<pre><code>import torch
import numpy as np
import cv2
BATCH_SIZE = 1
WIDTH = 640
HEIGHT = 360
def calculate_grid(B, H, W, dtype, device='cuda'):
xx = torch.arange(0, W, device=device).view(1, -1).repeat(H, 1).type(dtype)
yy = torch.arange(0, H, device=device).view(-1, 1).repeat(1, W).type(dtype)
xx = xx + yy * 0.25
if B > 1:
xx = xx.view(1, 1, H, W).repeat(B, 1, 1, 1)
yy = yy.view(1, 1, H, W).repeat(B, 1, 1, 1)
else:
xx = xx.view(1, 1, H, W)
yy = yy.view(1, 1, H, W)
vgrid = torch.cat((xx, yy), 1).type(dtype)
return vgrid.type(dtype)
def modify_grid(vgrid, H, W):
vgrid = torch.cat([
torch.sub(2.0 * vgrid[:, :1, :, :].clone() / max(W - 1, 1), 1.0),
torch.sub(2.0 * vgrid[:, 1:2, :, :].clone() / max(H - 1, 1), 1.0),
vgrid[:, 2:, :, :]], dim=1)
vgrid = vgrid.permute(0, 2, 3, 1)
return vgrid
class GridSamplingBlock(torch.nn.Module):
def __init__(self):
super(GridSamplingBlock, self).__init__()
def forward(self, input, vgrid):
output = torch.nn.functional.grid_sample(input, vgrid)
return output
if __name__ == '__main__':
model = torch.nn.DataParallel(GridSamplingBlock())
model.cuda()
print("Reading inputs")
img = cv2.imread("result/left_frame_rect_0373.png")
img = cv2.resize(cv2.cvtColor(img, cv2.COLOR_BGR2GRAY), (WIDTH, HEIGHT))
img_in = torch.from_numpy(img.astype(float)).view(1, 1, HEIGHT, WIDTH).cuda()
vgrid = calculate_grid(BATCH_SIZE, HEIGHT, WIDTH, img_in.dtype)
vgrid = modify_grid(vgrid, HEIGHT, WIDTH)
np.save("result/grid", vgrid.cpu().detach().numpy())
print("Getting output")
with torch.no_grad():
model.module.eval()
img_out = model.module(img_in, vgrid)
img = img_out.cpu().detach().numpy().squeeze()
cv2.imwrite("result/grid_sample_test_output.png", img.astype(np.uint8))
</code></pre>
<p>Saved grid is used for both calibration and inference of the TensorRT model.</p>
<p>So the questions are:</p>
<ul>
<li>Is it valid to apply INT8 quantization to functions with at least one
indexing input (like grid_sample)? Doesn't such quantization lead to
significant change of the result (if we apply INT8 quantization to
the input with the range [0..640) for example)?</li>
<li>How INT8 quantization works with the custom plugin, if only FP32 and FP16 are implemented in this plugin code?</li>
<li>Is the same result of the test network in TensorRT with and without INT8 quantization obtained due to the fact that the grid_sample input is actually the network input?</li>
</ul>
<p>My environment:</p>
<ul>
<li>TensorRT Version: 7</li>
<li>GPU Type: NVidia GeForce GTX 1050 Ti</li>
<li>Nvidia Driver Version: 470.63.01</li>
<li>CUDA Version: 10.2.89</li>
<li>CUDNN Version: 8.1.1</li>
<li>Operating System + Version: Ubuntu 18.04</li>
<li>Python Version (if applicable): 3.7</li>
<li>PyTorch Version (if applicable): 1.9</li>
</ul>
<p>Steps to reproduce:</p>
<ul>
<li>Run the test code to save the grid and get Torch result. Use any
input image for test.</li>
<li>Build TensorRT OSS with the custom plugin according to
this <a href="https://github.com/TrojanXu/onnxparser-trt-plugin-sample" rel="nofollow noreferrer">sample</a>. The latest
version of TRT OSS requires some adaptation of GridSamplePlugin, so
better to use the recomended TensorRT OSS version.</li>
<li>Create ONNX model according to the <a href="https://github.com/TrojanXu/onnxparser-trt-plugin-sample" rel="nofollow noreferrer">code example</a>.</li>
<li>Create TensorRT engine with or without INT8 quantization and run the inference. In my C++ code I used <a href="https://github.com/llohse/libnpy" rel="nofollow noreferrer">https://github.com/llohse/libnpy</a> for reading grid.npy file.</li>
</ul>
|
<p>You can break your model into 2 parts, one before grid sample and another after it, and do int8 quantization respectively. Having grid_sample work in INT8 will compromise your model performance greatly.
This will result in a change in your network structure so it may change the optimization of the graph.</p>
| 1,503
|
implement quantization
|
Spatially invariant Vector Quantization
|
https://stackoverflow.com/questions/13802434/spatially-invariant-vector-quantization
|
<p>I am trying to implement the <a href="http://www.jpathinformatics.org/article.asp?issn=2153-3539;year=2011;volume=2;issue=1;spage=13;epage=13;aulast=Hipp" rel="nofollow" title="original paper">algorithm</a> by Jason Hipp et al. There is also a <a href="http://www.pathinformatics.pitt.edu/sites/default/files/pathinfo/content/PI2011-Quant%20Histo-%20Jasonhipp-vfinal.pdf" rel="nofollow">presentation</a>, which is shorter and more comprehensive. </p>
<p>A brief description of their approach:</p>
<p>They use <strong>Vector Quantization</strong> as a tool to distinguish between foreground and backgroud in any given image. However, instead of using square regions as feature vectors to generate the Codewords, they use circles. This is supposed to decrease the computational complexity. With a circle as predicate vector, the matching problem is reduced to a linear pattern matching task and allows for spatially invariant matching. Hence the method is called <strong>Spatially Invariant Vector Quantization</strong>. </p>
<p>So basically, a predicate vector is chosen interactively and then the image space is queried exhaustively for the correlation of this predicate vector with the current position.</p>
<p>My questions are: </p>
<ul>
<li><p>Where in the whole algorithm do they generate the Codebook? And how? </p></li>
<li><p>I cannot see how to choose the parameters for a Codebook to be generated. If they sample all possible circles in all possible positions in the image first, this is computationally extremely heavy. How do they determine the number of clusters/codewords to be generated?</p></li>
<li><p>Why would I wobble the sub-rings against each other?</p></li>
</ul>
<p>Right now my implementation basically includes one circle with one radius as a predicate vector. It marches through the native image space and correlates the predicate vector with the circle around the current pixel in all possible rotations. This is an extremely slow process and I cannot see the benefits from their algorithm.
I have not implemented anything that comes close to a Vector Quantization because I cannot see how this would work. </p>
<p>Any hint or thought is appreciated. The authors of the method didn't respond to my questions, unfortunately.</p>
|
<p>Your first two questions are not particular to this algorithm, but any vector quantization algorithm. Here is a web page that describes in relatively easy-to-understand terms how to do vector quantization, including generation of codebooks: <a href="http://www.data-compression.com/vq.html" rel="nofollow">http://www.data-compression.com/vq.html</a>.</p>
<p>About Wobble: In this algorithm the key observation is that by vectorizing as rings the surface will not be tessellated (fully covered). For example, if you use squares, they tesselate the surface (completely cover it). Overlapping rings will not fully cover the image necessarily. For this reason, pixels which are "between" rings can get missed and cause a failure to match. To compensate for this, the author "wobbles" the rings back and forth so that eventually all the pixels get covered.</p>
| 1,504
|
implement quantization
|
Activations Quantization for Convolutional Neural Network
|
https://stackoverflow.com/questions/52700676/activations-quantization-for-convolutional-neural-network
|
<p>I am using Caffe to execute some Convolutional Neural Networks. However, my idea is executing the inference procedure by using quantized activations. Does anybody know the best way to do so? I've been looking up Ristretto, but I am not sure whether that framework quantizes the activations or only the weights. Does anybody know anything about that? </p>
<p>Otherwise, I've heard on some forums that caffev2 implements something related to quantization but however I am not able to see anything about that on the official website. </p>
<p>Thank you all for your attention,
Francisco.</p>
| 1,505
|
|
implement quantization
|
Does C have a Quantization function?
|
https://stackoverflow.com/questions/1966739/does-c-have-a-quantization-function
|
<p>I have a buffer with many positive 16bit values (which are stored as doubles) that I would like to quantize to 8bit (0-255 values).</p>
<p>According to <a href="http://en.wikipedia.org/wiki/Quantization_%28signal_processing%29#Mathematical_description" rel="nofollow noreferrer">Wikipedia</a> the process would be:</p>
<ul>
<li>Normalize 16 bit values. I.e. find the largest and divide with this.</li>
<li>Use the Q(x) formula with M=8.</li>
</ul>
<p>So I wonder, if C have a function that can do this quantization, or does anyone know of a C implementation that I could use?</p>
<p>Lots of love,
Louise</p>
|
<p>Assuming the value <code>d</code> is in the interval <code>[0.0, max]</code>:</p>
<pre><code>unsigned char quantize(double d, double max)
{
return (unsigned char)((d / max) * 255.0);
}
</code></pre>
<p>I'm not sure what you mean by "16-bit values;" double precision values are 64-bit on any system using IEEE-754. However, if you have values of another numeric type, the process is effectively the same.</p>
| 1,506
|
implement quantization
|
Is there a differentiable algorithm for image quantization?
|
https://stackoverflow.com/questions/74142324/is-there-a-differentiable-algorithm-for-image-quantization
|
<p>I am implementing an autoencoder, used to rebuild color images. The loss function I want to use requires a reduced color set (max ~100 different colors) but I am struggling to find a suitable differentiable algorithm.</p>
<p>Another doubt I have is the following: is it better to apply such quantization directly in the loss function, or can I implement it in a custom non-trainable layer? In the second case, need the algorithm to be differentiable?</p>
<p>My first idea approaching this problem was to quantize the images before feeding them to the network, but I don`t know how to "force" the network to produce only the quantized colors as output.</p>
<p>Any suggestion is greatly appreciated, I do not need code, just some ideas or new perspectives. Being pretty new to Tensorflow I am probably missing something.</p>
|
<p>If you want to compress <strong>the image</strong>, it seems you want to find discrete color set for image compression. In that case auto-encoder is not suitable approach for image compression.</p>
<p>The general auto-encoder compress tensor of images(<code>B x C x H x W</code>) to latent code of each images(<code>B x D</code>, typically <code>D = 512</code>). The beauty of this approach is that the optimal latent space is found 'automatically'.</p>
<p>Nevertheless if you want to utilize convex optimization tool of tensorflow, some continuous relaxation technique like interpolation could be helpul.</p>
<p>In the following paper, they utilize continuous relaxation for discrete path selection of neural network.</p>
<p>Liu, H., Simonyan, K., & Yang, Y. (2018). Darts: Differentiable architecture search. ICLR.
<a href="https://i.sstatic.net/RJ24j.png" rel="nofollow noreferrer"><img src="https://i.sstatic.net/RJ24j.png" alt="enter image description here" /></a></p>
<p>In the following paper, they utilize interpolation to learn quantized kernel bank on look-up table.</p>
<p>Jo, Y., & Kim, S. J. (2021). Practical single-image super-resolution using look-up table. CVPR.
<a href="https://i.sstatic.net/kRw72.png" rel="nofollow noreferrer"><img src="https://i.sstatic.net/kRw72.png" alt="enter image description here" /></a></p>
<p>Both of them provide codes.</p>
| 1,507
|
implement quantization
|
TFLiteConverter parameters for optmization on TensorFlow 1.x
|
https://stackoverflow.com/questions/60998416/tfliteconverter-parameters-for-optmization-on-tensorflow-1-x
|
<p>I've been learning about quantization on TensorFlow 2.x using TFLiteConverter, however I'm implementing a project on TensorFlow 1.13 and I'd like to know how to do the same things on this version.</p>
<p>For example, as far as I've observed the following commands do the same thing</p>
<pre><code># tf 1.x
converter.post_training_quantize = True
# tf 2.x
converter.optimizations = [tf.lite.Optimize.OPTIMIZE_FOR_SIZE]
</code></pre>
<p>Is it right? And what about <strong>integer quantization</strong> and <strong>quantization aware training</strong>, how to implement them?</p>
|
<p>AFAIK, the following two are equivalent.</p>
<pre><code># tf 1.x
converter.post_training_quantize = True
# tf 2.x
converter.optimizations = [tf.lite.Optimize.DEFAULT]
</code></pre>
<p><code>converter.optimizations = [tf.lite.Optimize.OPTIMIZE_FOR_SIZE]</code> is used for full integer quantization. </p>
<p>Please note that post training quantization is simple when compared to quantization aware training (QAT) but QAT provides higher model accuracy. Generally it is suggested to use post training quantization. If the performance of post training quantization doesn't meet your requirements, then go for QAT.</p>
<p>As you might have already know, there are several levels of quantizations can be done to optimize for size and performance. The following guide covers full integer quantization and other techniques (float quantization, float16 quantization etc) </p>
<p><a href="https://www.tensorflow.org/lite/performance/model_optimization" rel="nofollow noreferrer">https://www.tensorflow.org/lite/performance/model_optimization</a></p>
<p>Here is the best resource to follow on the guidelines of QAT.</p>
<p><a href="https://www.tensorflow.org/model_optimization/guide/quantization/training" rel="nofollow noreferrer">https://www.tensorflow.org/model_optimization/guide/quantization/training</a></p>
| 1,508
|
implement quantization
|
Algorithm for color quantization/reduced image color palette in JavaScript?
|
https://stackoverflow.com/questions/6205955/algorithm-for-color-quantization-reduced-image-color-palette-in-javascript
|
<p>I'm writing a web app that takes a user-submitted image, gets the pixel data via a <code>canvas</code> element, does some processing, and then renders the image using vector shapes (using <a href="http://vis.stanford.edu/protovis/" rel="nofollow noreferrer">Protovis</a>). It's working well, but I end up with several thousand colors, and I'd like to let the user pick a target palette size and reduce the color palette to that size.</p>
<p>At the point where I want to reduce the color space, I'm working with an array of RGB pixel data, like this:</p>
<pre><code>[[190,197,190], [202,204,200], [207,214,210], [211,214,211], [205,207,207], ...]
</code></pre>
<p>I tried the naive option of just removing least-significant bits from the colors, but the results were pretty bad. I've done some research on <a href="http://en.wikipedia.org/wiki/Color_quantization" rel="nofollow noreferrer">color quantization</a> algorithms, but have yet to find a clear description of how to implement one. I could probably work out a cludgy way to send this to the server, run it though an image processing program, and send the resulting palette back, but I'd prefer to do it in JavaScript on the client side.</p>
<p>Does anyone have an example of a clearly explained algorithm that would work here? The goal is to reduce a palette of several thousand colors to a smaller palette optimized for this specific image.</p>
<p><strong>Edit (7/25/11):</strong> I took @Pointy's suggestion and implemented (most of) Leptonica's MMCQ (modified median cut quantization) in JavaScript. If you're interested, you can <a href="https://gist.github.com/1104622" rel="nofollow noreferrer">see the code here.</a></p>
<p><strong>Edit (8/5/11):</strong> The <a href="http://harthur.github.com/clusterfck/" rel="nofollow noreferrer">clusterfck library</a> looks like another great option for this (though I think it's a bit slower than my implementation).</p>
|
<p>With the caveat that I don't claim any expertise at all in any field of image processing: I read over the Wikipedia article you linked, and from there found Dan Bloomberg's <a href="http://www.leptonica.com">Leptonica</a>. From there you can <a href="http://www.leptonica.com/download.html">download</a> the sources for the algorithms discussed and explained.</p>
<p>The source code is in C, which hopefully is close enough to JavaScript (at least in the core "formula" parts) to be understandable. The basic ideas behind the "MMCQ" algorithm don't seem super-complicated. It's really just some heuristic tricks for splitting up the 3-dimensional color space into sub-cubes based on the way colors in an image clump together.</p>
| 1,509
|
implement quantization
|
"NotImplementedError: Could not run 'aten::add.out' with arguments from the 'QuantizedCPU' backend" while implementing QAT on resnet18 using pytorch
|
https://stackoverflow.com/questions/79240688/notimplementederror-could-not-run-atenadd-out-with-arguments-from-the-qua
|
<p>I am trying to implement Quantization Aware Training(QAT) resnet18 model. While inferring I get this error</p>
<pre><code>NotImplementedError: Could not run 'aten::add.out' with arguments from the 'QuantizedCPU' backend
</code></pre>
<p>I am trying to follow <a href="https://pytorch.org/docs/stable/quantization.html" rel="nofollow noreferrer">this documentation</a> by pytorch for using their QAT API</p>
<p>Here is my code, I am also attaching a <a href="https://colab.research.google.com/drive/1i1Uc5wvSkUCE4zfWW2Rda9c-C0LURQOh#scrollTo=yEfnWXLQYohD" rel="nofollow noreferrer">google collab notebook link</a></p>
<p>Block 1 - Importing the necessary libraries, defining training and evaluation functions</p>
<pre><code>import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
from torchvision.models import resnet18
import matplotlib.pyplot as plt
import copy
import numpy as np
import os
def evaluate_model(model, test_loader, device, criterion=None):
model.eval()
model.to(device)
running_loss = 0
running_corrects = 0
for inputs, labels in test_loader:
inputs = inputs.to(device)
labels = labels.to(device)
outputs = model(inputs)
_, preds = torch.max(outputs, 1)
if criterion is not None:
loss = criterion(outputs, labels).item()
else:
loss = 0
running_loss += loss * inputs.size(0)
running_corrects += torch.sum(preds == labels.data)
eval_loss = running_loss / len(test_loader.dataset)
eval_accuracy = running_corrects / len(test_loader.dataset)
return eval_loss, eval_accuracy
def train_model(model, train_loader, test_loader, device, learning_rate=1e-1, num_epochs=200):
criterion = nn.CrossEntropyLoss()
model.to(device)
#optimizer = optim.SGD(model.parameters(), lr=learning_rate, momentum=0.9, weight_decay=1e-4)
optimizer = optim.Adam(model.parameters(), lr=1e-4)
scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=[100, 150], gamma=0.1, last_epoch=-1)
model.eval()
eval_loss, eval_accuracy = evaluate_model(model=model, test_loader=test_loader, device=device, criterion=criterion)
print("Epoch: {:02d} Eval Loss: {:.3f} Eval Acc: {:.3f}".format(-1, eval_loss, eval_accuracy))
for epoch in range(num_epochs):
model.train()
running_loss = 0
running_corrects = 0
for inputs, labels in train_loader:
inputs = inputs.to(device)
labels = labels.to(device)
optimizer.zero_grad()
outputs = model(inputs)
_, preds = torch.max(outputs, 1)
loss = criterion(outputs, labels)
if torch.isnan(loss):
print("NaN in Loss!")
return model
loss.backward()
optimizer.step()
running_loss += loss.item() * inputs.size(0)
running_corrects += torch.sum(preds == labels.data)
train_loss = running_loss / len(train_loader.dataset)
train_accuracy = running_corrects / len(train_loader.dataset)
model.eval()
eval_loss, eval_accuracy = evaluate_model(model=model, test_loader=test_loader, device=device, criterion=criterion)
scheduler.step()
print("Epoch: {:03d} Train Loss: {:.3f} Train Acc: {:.3f} Eval Loss: {:.3f} Eval Acc: {:.3f}".format(epoch, train_loss, train_accuracy, eval_loss, eval_accuracy))
return model
</code></pre>
<p>Block 2 - Loading trainset and testset (CIFAR 100 resized to 224*224)</p>
<pre><code>transform_train = transforms.Compose([
transforms.Resize(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
transform_test = transforms.Compose([
transforms.Resize(224),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
trainset = torchvision.datasets.CIFAR100(root='./data', train=True, download=True, transform=transform_train)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=128, shuffle=True, num_workers=2)
testset = torchvision.datasets.CIFAR100(root='./data', train=False, download=True, transform=transform_test)
testloader = torch.utils.data.DataLoader(testset, batch_size=128, shuffle=False, num_workers=2)
print("Data loaded and transformed successfully!")
</code></pre>
<p>Block 3 -</p>
<pre><code>class QuantizedResNet18(nn.Module):
def __init__(self, model_fp32):
super().__init__()
# QuantStub converts tensors from floating point to quantized.
# This will only be used for inputs.
self.quant = torch.ao.quantization.QuantStub()
# DeQuantStub converts tensors from quantized to floating point.
# This will only be used for outputs.
self.dequant = torch.ao.quantization.DeQuantStub()
# FP32 model
self.model_fp32 = model_fp32
def forward(self, x):
# manually specify where tensors will be converted from floating
# point to quantized in the quantized model
print(f"Input shape before quant: {x.shape}, dtype: {x.dtype}")
x = self.quant(x)
print(f"Input shape after quant: {x.shape}, dtype: {x.dtype}")
x = self.model_fp32(x)
print(f"Input shape: {x.shape}, dtype: {x.dtype}")
# manually specify where tensors will be converted from quantized
# to floating point in the quantized model
x = self.dequant(x)
print(f"Input shape: {x.shape}, dtype: {x.dtype}")
return x
model = resnet18(num_classes=100, pretrained=False)
fused_model = copy.deepcopy(model)
fused_model.eval()
qconfig = torch.ao.quantization.get_default_qconfig('fbgemm')
fused_model.qconfig = qconfig
# Fuse the model in place rather manually.
fused_model = torch.ao.quantization.fuse_modules(fused_model, [["conv1", "bn1", "relu"]], inplace=True)
for module_name, module in fused_model.named_children():
if "layer" in module_name:
for basic_block_name, basic_block in module.named_children():
torch.ao.quantization.fuse_modules(basic_block, [["conv1", "bn1", "relu"], ["conv2", "bn2"]], inplace=True)
for sub_block_name, sub_block in basic_block.named_children():
if sub_block_name == "downsample":
torch.ao.quantization.fuse_modules(sub_block, [["0", "1"]], inplace=True)
quantized_model_1 = QuantizedResNet18(model_fp32=fused_model)
quantized_model_1.qconfig = qconfig
cuda_device = torch.device("cuda:0")
quantized_model_1_prepared = torch.ao.quantization.prepare_qat(quantized_model_1.train())
trained_quantized_model_1_prepared = train_model(model=quantized_model_1_prepared, train_loader=trainloader, test_loader=testloader, device=cuda_device, learning_rate=1e-3, num_epochs=1)
cpu_device = torch.device("cpu:0")
trained_quantized_model_1_prepared.to(cpu_device)
trained_quantized_model_1_prepared.eval()
trained_quantized_model_1_prepared_int8 = torch.ao.quantization.convert(trained_quantized_model_1_prepared)
print(evaluate_model(model=trained_quantized_model_1_prepared_int8, test_loader=testloader, device=cpu_device))
</code></pre>
<p>the issue is in the last line when I try to run evaluate_model function, particularly while inferring (outputs = model(inputs))</p>
<p>I get the following error</p>
<pre><code>NotImplementedError: Could not run 'aten::add.out' with arguments from the 'QuantizedCPU' backend. This could be because the operator doesn't exist for this backend, or was omitted during the selective/custom build process (if using custom build). If you are a Facebook employee using PyTorch on mobile, please visit https://fburl.com/ptmfixes for possible resolutions. 'aten::add.out' is only available for these backends: [CPU, CUDA, Meta, MkldnnCPU, SparseCPU, SparseCUDA, SparseMeta, SparseCsrCPU, SparseCsrCUDA, SparseCsrMeta, BackendSelect, Python, FuncTorchDynamicLayerBackMode, Functionalize, Named, Conjugate, Negative, ZeroTensor, ADInplaceOrView, AutogradOther, AutogradCPU, AutogradCUDA, AutogradHIP, AutogradXLA, AutogradMPS, AutogradIPU, AutogradXPU, AutogradHPU, AutogradVE, AutogradLazy, AutogradMTIA, AutogradPrivateUse1, AutogradPrivateUse2, AutogradPrivateUse3, AutogradMeta, AutogradNestedTensor, Tracer, AutocastCPU, AutocastXPU, AutocastMPS, AutocastCUDA, FuncTorchBatched, BatchedNestedTensor, FuncTorchVmapMode, Batched, VmapMode, FuncTorchGradWrapper, PythonTLSSnapshot,
</code></pre>
|
<p>This tutorial tells that for torch 2.0 this feature is beta and you need to adjust original model with at least one change (<a href="https://pytorch.org/tutorials/advanced/static_quantization_tutorial.html#model-architecture" rel="nofollow noreferrer">https://pytorch.org/tutorials/advanced/static_quantization_tutorial.html#model-architecture</a>) for residual addition:</p>
<blockquote>
<p>Replacing addition with nn.quantized.FloatFunctional</p>
</blockquote>
<p>You can see in your error trace that this line of code throws the error:</p>
<pre><code> out += identity
</code></pre>
<p><a href="https://github.com/pytorch/vision/blob/229d8523bfa9a2696872d76b1cdb6815028f1e03/torchvision/models/resnet.py#L102" rel="nofollow noreferrer">https://github.com/pytorch/vision/blob/229d8523bfa9a2696872d76b1cdb6815028f1e03/torchvision/models/resnet.py#L102</a></p>
<p>So we need to:</p>
<ol>
<li>reimplement BasicBlock by replacing += operator with skip_add;</li>
<li>inject BasicBlock to the Resnet constructor.</li>
</ol>
<h1>Step 1</h1>
<pre><code>from functools import partial
from typing import Any, Callable, List, Optional, Type, Union
import torch
import torch.nn as nn
from torch import Tensor
from torchvision.transforms._presets import ImageClassification
from torchvision.utils import _log_api_usage_once
from torchvision.models.resnet import Bottleneck
from torchvision.models.resnet import conv3x3
class BasicBlock(nn.Module):
expansion: int = 1
def __init__(
self,
inplanes: int,
planes: int,
stride: int = 1,
downsample: Optional[nn.Module] = None,
groups: int = 1,
base_width: int = 64,
dilation: int = 1,
norm_layer: Optional[Callable[..., nn.Module]] = None,
) -> None:
super().__init__()
if norm_layer is None:
norm_layer = nn.BatchNorm2d
if groups != 1 or base_width != 64:
raise ValueError("BasicBlock only supports groups=1 and base_width=64")
if dilation > 1:
raise NotImplementedError("Dilation > 1 not supported in BasicBlock")
# Both self.conv1 and self.downsample layers downsample the input when stride != 1
self.conv1 = conv3x3(inplanes, planes, stride)
self.bn1 = norm_layer(planes)
self.relu = nn.ReLU(inplace=True)
self.conv2 = conv3x3(planes, planes)
self.bn2 = norm_layer(planes)
self.downsample = downsample
self.stride = stride
self.skip_add = nn.quantized.FloatFunctional()
def forward(self, x: Tensor) -> Tensor:
identity = 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:
identity = self.downsample(x)
out = self.skip_add.add(out, identity)
out = self.relu(out)
return out
</code></pre>
<h1>Step 2</h1>
<p>Inject this by creating new constructor method for quantized model.</p>
<pre><code>from torchvision.models.resnet import ResNet18_Weights, _resnet
from torchvision.models._api import register_model, Weights, WeightsEnum
from torchvision.models._utils import _make_divisible, _ovewrite_named_param, handle_legacy_interface
@register_model()
@handle_legacy_interface(weights=("pretrained", ResNet18_Weights.IMAGENET1K_V1))
def quantizedresnet18(*, weights: Optional[ResNet18_Weights] = None, progress: bool = True, **kwargs: Any):
weights = ResNet18_Weights.verify(weights)
return _resnet(BasicBlock, [2, 2, 2, 2], weights, progress, **kwargs)
</code></pre>
<h1>Step 3</h1>
<p>Go back to the cell with</p>
<pre><code>model = resnet18(num_classes=100, pretrained=False)
fused_model = copy.deepcopy(model)
fused_model.eval()
qconfig = torch.ao.quantization.get_default_qconfig('fbgemm')
fused_model.qconfig = qconfig
</code></pre>
<p>And change it with this (see the first line is changed)</p>
<pre><code>model = quantizedresnet18(num_classes=100, pretrained=False)
fused_model = copy.deepcopy(model)
fused_model.eval()
qconfig = torch.ao.quantization.get_default_qconfig('fbgemm')
fused_model.qconfig = qconfig
</code></pre>
<p>Then execute all cells below again.</p>
| 1,510
|
implement quantization
|
How to manually dequantize the output of a layer and requantize it for the next layer in Pytorch?
|
https://stackoverflow.com/questions/78239906/how-to-manually-dequantize-the-output-of-a-layer-and-requantize-it-for-the-next
|
<p>I am working on school project that requires me to perform manual quantization of each layer of a model. Specifically, I want to implement manually:</p>
<blockquote>
<p>Quantized activation, combined with quantized weight A - layer A -
quantized output - dequantized output - requantized output, combined
with quantized weight B - layer B - ...</p>
</blockquote>
<p>I know Pytorch already have a quantization function, but that function is limited to int8. I would like to perform quantization from bit = 16 to bit = 2, and then compare their accuracy.</p>
<p>The issue I encountered is that after quantization, the output of a layer is multi-magnitude larger (with bit = 16), and I don't know how to dequantize it back. I am performing the quantization with the same min and max of both activation and weight. So here is an example:</p>
<pre><code>Activation = [1,2,3,4]
Weight = [5,6,7,8]
Min and max across activation and weight = 1, 8
Expected, non-quantized output = 70
Quantize with bit = 16
Quantized activation = [-32768, -23406, -14044, -4681]
Quantized weight = [4681, 14043, 23405, 32767]
Quantized output = -964159613
Dequantize output with min = 1, max = 8 = -102980
</code></pre>
<p>The calculation makes sense to me, because the output involves multiplying activations and weigths, their magnitude increase is also multiplied together. If I perform dequantization once with the original min and max, it is reasonable to have a much larger output.</p>
<p>How does Pytorch handle dequantization? I attempted to locate the quantization of Pytorch, but I could not locate it. How to dequantize the output?</p>
|
<p>Fundamentally you are looking at converting the matrix multiplication :</p>
<p>$$Y = WX+b$$</p>
<p>De quantization is carried out according to this formula :
Where $S_i, Z_i$ are the scale and zero point of the $X$ (activations in your case) and bias, $b$.</p>
<p>$$Y = S_xS_w(X_q-Z_x)(W_q-Z_w) + S_b(b_q-Z_b)$$</p>
<p>I am not sure your quantization formula looks correct since it does not involve a scale and zero point. But if you give me the formula used to quantize, then I can probably revise it for you. I go into painful detail about this in my blog and it would be worth your while to try to recreate it with your quantization formula :</p>
<p><a href="https://franciscormendes.github.io/2024/05/16/quantization-layer-details/" rel="nofollow noreferrer">https://franciscormendes.github.io/2024/05/16/quantization-layer-details/</a></p>
| 1,511
|
implement quantization
|
Faster implementation to quantize an image with an existing palette?
|
https://stackoverflow.com/questions/50801935/faster-implementation-to-quantize-an-image-with-an-existing-palette
|
<p>I am using Python 3.6 to perform basic image manipulation through Pillow. Currently, I am attempting to take 32-bit PNG images (RGBA) of arbitrary color compositions and sizes and quantize them to a known palette of 16 colors. Optimally, this quantization method should be able to leave fully transparent (A = 0) pixels alone, while forcing all semi-transparent pixels to be fully opaque (A = 255). I have already devised working code that performs this, but I wonder if it may be inefficient:</p>
<pre><code>import math
from PIL import Image
# a list of 16 RGBA tuples
palette = [
(0, 0, 0, 255),
# ...
]
with Image.open('some_image.png').convert('RGBA') as img:
for py in range(img.height):
for px in range(img.width):
pix = img.getpixel((px, py))
if pix[3] == 0: # Ignore fully transparent pixels
continue
# Perform exhaustive search for closest Euclidean distance
dist = 450
best_fit = (0, 0, 0, 0)
for c in palette:
if pix[:3] == c: # If pixel matches exactly, break
best_fit = c
break
tmp = sqrt(pow(pix[0]-c[0], 2) + pow(pix[1]-c[1], 2) + pow(pix[2]-c[2], 2))
if tmp < dist:
dist = tmp
best_fit = c
img.putpixel((px, py), best_fit + (255,))
img.save('quantized.png')
</code></pre>
<p>I think of two main inefficiencies of this code:</p>
<ul>
<li><code>Image.putpixel()</code> is a slow operation</li>
<li>Calculating the distance function multiple times per pixel is computationally wasteful</li>
</ul>
<p>Is there a <em>faster</em> method to do this?</p>
<p>I've noted that Pillow has a native function <code>Image.quantize()</code> that seems to do exactly what I want. But as it is coded, it forces <em>dithering</em> in the result, which I do not want. This has been brought up in <a href="https://stackoverflow.com/questions/29433243/convert-image-to-specific-palette-using-pil-without-dithering">another StackOverflow question</a>. The answer to that question was simply to extract the internal Pillow code and tweak the control variable for dithering, which I tested, but I find that Pillow corrupts the palette I give it and consistently yields an image where the quantized colors are considerably darker than they should be.</p>
<p><code>Image.point()</code> is a tantalizing method, but it only works on each color channel individually, where color quantization requires working with all channels as a set. It'd be nice to be able to force all of the channels into a single channel of 32-bit integer values, which <em>seems</em> to be what the ill-documented mode "I" would do, but if I run <code>img.convert('I')</code>, I get a completely greyscale result, destroying all color.</p>
<p>An alternative method seems to be using NumPy and altering the image directly. I've attempted to create a lookup table of RGB values, but the three-dimensional indexing of NumPy's syntax is driving me insane. Ideally I'd like some kind of code that works like this:</p>
<pre><code>img_arr = numpy.array(img)
# Find all unique colors
unique_colors = numpy.unique(arr, axis=0)
# Generate lookup table
colormap = numpy.empty(unique_colors.shape)
for i, c in enumerate(unique_colors):
dist = 450
best_fit = None
for pc in palette:
tmp = sqrt(pow(c[0] - pc[0], 2) + pow(c[1] - pc[1], 2) + pow(c[2] - pc[2], 2))
if tmp < dist:
dist = tmp
best_fit = pc
colormap[i] = best_fit
# Hypothetical pseudocode I can't seem to write out
for iy in range(arr.size):
for ix in range(arr[0].size):
if arr[iy, ix, 3] == 0: # Skip transparent
continue
index = # Find index of matching color in unique_colors, somehow
arr[iy, ix] = colormap[index]
</code></pre>
<p>I note with this hypothetical example that <code>numpy.unique()</code> is another slow operation, since it sorts the output. Since I cannot seem to finish the code the way I want, I haven't been able to test if this method is faster anyway.</p>
<p>I've also considered attempting to flatten the RGBA axis by converting the values to a 32-bit integer and desiring to create a one-dimensional lookup table with the simpler index:</p>
<pre><code>def shift(a):
return a[0] << 24 | a[1] << 16 | a[2] << 8 | a[3]
img_arr = numpy.apply_along_axis(shift, 1, img_arr)
</code></pre>
<p>But this operation seemed noticeably slow on its own.</p>
<p>I would prefer answers that involve <strong>only Pillow and/or NumPy</strong>, please. Unless using another library demonstrates a dramatic computational speed increase over any PIL- or NumPy-native solution, I don't want to import extraneous libraries to do something these two libraries should be reasonably capable of on their own.</p>
|
<p><code>for</code> loops should be avoided for speed.</p>
<p>I think you should make a tensor like:</p>
<pre><code>d2[x,y,color_index,rgb] = distance_squared
</code></pre>
<p>where rgb = 0..2 (0 = r, 1 = g, 2 = b).</p>
<p>Then compute the distance:</p>
<pre><code>d[x,y,color_index] =
sqrt(sum(rgb,d2))
</code></pre>
<p>Then select the color_index with the minimal distance:</p>
<pre><code>c[x,y] = min_index(color_index, d)
</code></pre>
<p>Finally replace alpha as needed:</p>
<pre><code>alpha = ceil(orig_image.alpha)
img = c,alpha
</code></pre>
| 1,512
|
implement quantization
|
Stable Diffusion v1.4 PTQ on both weight and activation
|
https://stackoverflow.com/questions/79555026/stable-diffusion-v1-4-ptq-on-both-weight-and-activation
|
<p>I'm currently working on quantizing the Stable Diffusion v1.4 checkpoint without relying on external libraries such as torch.quantization or other quantization toolkits. I’m exploring two scenarios:</p>
<p>Dynamic Quantization: I store weights in INT8 but dequantize them during inference. This approach works as expected.</p>
<p>Static Quantization: I store both weights and activations in INT8 and aim to perform INT8 × INT8 → INT32 → FP32 computations. However, I'm currently unsure how to modify the forward pass correctly to support true INT8 × INT8 operations. For now, I've defaulted back to FP32 computations due to shape mismatch or type expectation errors.</p>
<p>I have a few questions:</p>
<p>Which layers are safe to quantize, and which should remain in FP32? Right now, I wrap all nn.Conv2d and nn.Linear layers using a custom quantization wrapper, but I realize this may not be ideal and could affect layers that are sensitive to quantization. Any advice on which layers are typically more fragile in diffusion models would be very helpful.</p>
<p>How should I implement INT8 × INT8 → INT32 → FP32 computation properly for both nn.Conv2d and nn.Linear**?** I understand the theoretical flow, but I’m unsure how to structure the actual implementation and quantization steps, especially when dealing with scale/zero-point calibration and efficient computation.</p>
<p>Also, when I initially attempted true INT8 × INT8 inference, I ran into data type mismatch issues and fell back to using FP32 computations for now. I’m planning to implement proper INT8 matrix multiplication later once I’m more comfortable with writing custom CUDA kernels.</p>
<p>Here’s my GitHub repository for reference:
<a href="https://github.com/kyohmin/sd_v1.4_quantization" rel="nofollow noreferrer">https://github.com/kyohmin/sd_v1.4_quantization</a></p>
<p>I know the codebase isn’t fully polished, so I’d greatly appreciate any architectural or implementation feedback as well.</p>
<p>Thanks in advance for your time and help!</p>
<p>Below is my Wrapper Class code</p>
<pre class="lang-none prettyprint-override"><code>import torch
import torch.nn as nn
import torch.nn.functional as F
from quantization.quantization import Quantization
class QuantWrapper(nn.Module):
def __init__(self, module, weight=None, weight_scale=None, weight_zero=None, activation_zero=0, activation_scale=1.0):
super().__init__()
self.module = module
self.use_weightquant = False
self.use_activationquant = True
# Weight Quant Parameters
self.register_buffer("weight", weight.to(torch.uint8) if weight is not None else None)
self.register_buffer("weight_scale", torch.tensor(weight_scale, dtype=torch.float32) if weight_scale is not None else None)
self.register_buffer("weight_zero", torch.tensor(weight_zero, dtype=torch.int32) if weight_zero is not None else None)
# Activation Quant Parameters
self.register_buffer("activation_scale", torch.tensor(activation_scale, dtype=torch.float32) if activation_scale is not None else None)
self.register_buffer("activation_zero", torch.tensor(activation_zero, dtype=torch.int32) if activation_zero is not None else None)
def update_weight_params(self, weight, scale, zero, dtype=torch.uint8):
self.weight = torch.tensor(weight, dtype=dtype)
self.weight_scale = torch.tensor(scale, dtype=torch.float32)
self.weight_zero = torch.tensor(zero, dtype=torch.float32)
self.use_weightquant = True
def update_activation_params(self, act_scale, act_zero):
self.act_scale = torch.tensor(act_scale, dtype=torch.float32)
self.act_zero = torch.tensor(act_zero, dtype=torch.float32)
self.use_activationquant = True
def forward(self, x):
# Calculate INT8 x INT8
if self.use_weightquant and self.use_activationquant:
quantized_activation, self.activation_scale, self.activation_zero, dtype = Quantization.quantize(x, quantization_mode="asymmetric", range_estimator_type="min_max", bits=8, zero=self.activation_zero, scale=self.activation_scale)
if isinstance(self.module, nn.Conv2d):
return F.conv2d(quantized_activation.to(torch.float32), self.weight.to(torch.float32), self.module.bias, self.module.stride, self.module.padding, self.module.dilation, self.module.groups)
elif isinstance(self.module, nn.Linear):
output = Quantization.int8_compute(quantized_weight=self.weight.to(torch.float32), quantized_activation=quantized_activation.to(torch.float32), target="linear", weight_scale=self.weight_scale, activation_scale=self.activation_scale, bias=self.module.bias)
# return F.linear(quantized_activation.to(torch.float32), self.weight.to(torch.float32), self.module.bias)
return output
# Calculate INT8 -> FP32 x FP32
elif self.use_weightquant and not self.use_activationquant:
dequantized_weight = Quantization.dequantize(self.weight, self.weight_zero, self.weight_scale)
if isinstance(self.module, nn.Conv2d):
return F.conv2d(x, dequantized_weight, self.module.bias, self.module.stride, self.module.padding, self.module.dilation, self.module.groups)
elif isinstance(self.module, nn.Linear):
return F.linear(x, dequantized_weight, self.module.bias)
else:
return self.module(x)
</code></pre>
| 1,513
|
|
implement quantization
|
how to perform color quantization in matlab or otherwise
|
https://stackoverflow.com/questions/10372681/how-to-perform-color-quantization-in-matlab-or-otherwise
|
<p>I am implementing a machine learning algorithm in matlab, and was doing some reading up on the color range of the human eye, and was informed that the human eye can only perceive about 17,000 colors, where as the images I have about 256^3 colours. What is the best way to quantization my images, in matlab or otherwise.
Also, as a side question in terms of machine learning, which one is better to use bitmap or jpeg?</p>
|
<p>JPEG is a lossy format. You should not use it if your input data is not already JPEG. Even if so, you should not re-compress your data to avoid introduction of further artifacts.</p>
<p>A very simple, yet popular method for color quantization is the k-means algorithm. You can find it in Matlab. This is a good starting point. However, there exist a broad range of paradigms and methods in recent research.</p>
| 1,514
|
implement quantization
|
NeuQuant.js (JavaScript color quantization) hidden bug in JS conversion
|
https://stackoverflow.com/questions/16371712/neuquant-js-javascript-color-quantization-hidden-bug-in-js-conversion
|
<p><a href="https://github.com/antimatter15/jsgif/blob/master/NeuQuant.js" rel="nofollow noreferrer">NeuQuant.js</a> works well when the image width and height are a multiple of 100:</p>
<p><img src="https://i.sstatic.net/uiWXI.gif" alt="300x300 animated gif"> 300x300</p>
<p>Otherwise, there is obviously a bug:</p>
<p><img src="https://i.sstatic.net/cBfj8.gif" alt="299x300 animated gif"> 299x300</p>
<p>(These were made with <a href="http://meemoo.org/iframework/#gist/5513719" rel="nofollow noreferrer">this web app</a>.)</p>
<p>I'm 90% sure that the bug is in NeuQuant.js. I have made tests using it with <a href="https://github.com/antimatter15/jsgif" rel="nofollow noreferrer">jsgif</a> and <a href="https://github.com/deanm/omggif" rel="nofollow noreferrer">omggif</a>, and both encoders have the same bug. It is only obvious with photographic images (quantize to 256 colors) when the image size is anything other than a multiple of 100.</p>
<p>If you understand neural networks, color quantization, and/or issues with porting AS3 to JS, please take a look. The original porter has abandoned the project, and it is so close to working!</p>
<hr>
<p>Here is <a href="https://github.com/meemoo/iframework/blob/master/libs/omggif/omggif-worker.js" rel="nofollow noreferrer">my code</a> that implements it in a worker with OMGGIF:</p>
<pre class="lang-js prettyprint-override"><code>importScripts('omggif.js', 'NeuQuant.js');
var rgba2rgb = function (data) {
var pixels = [];
var count = 0;
var len = data.length;
for ( var i=0; i<len; i+=4 ) {
pixels[count++] = data[i];
pixels[count++] = data[i+1];
pixels[count++] = data[i+2];
}
return pixels;
}
var rgb2num = function(palette) {
var colors = [];
var count = 0;
var len = palette.length;
for ( var i=0; i<len; i+=3 ) {
colors[count++] = palette[i+2] | (palette[i+1] << 8) | (palette[i] << 16);
}
return colors;
}
self.onmessage = function(event) {
var frames = event.data.frames;
var framesLength = frames.length;
var delay = event.data.delay / 10;
var startTime = Date.now();
var buffer = new Uint8Array( frames[0].width * frames[0].height * framesLength * 5 );
var gif = new GifWriter( buffer, frames[0].width, frames[0].height, { loop: 0 } );
// var pixels = new Uint8Array( frames[0].width * frames[0].height );
var addFrame = function (frame) {
var data = frame.data;
// Make palette with NeuQuant.js
var nqInPixels = rgba2rgb(data);
var len = nqInPixels.length;
var nPix = len / 3;
var map = [];
var nq = new NeuQuant(nqInPixels, len, 10);
// initialize quantizer
var paletteRGB = nq.process(); // create reduced palette
var palette = rgb2num(paletteRGB);
// map image pixels to new palette
var k = 0;
for (var j = 0; j < nPix; j++) {
var index = nq.map(nqInPixels[k++] & 0xff, nqInPixels[k++] & 0xff, nqInPixels[k++] & 0xff);
// usedEntry[index] = true;
map[j] = index;
}
gif.addFrame( 0, 0, frame.width, frame.height, new Uint8Array( map ), { palette: new Uint32Array( palette ), delay: delay } );
}
// Add all frames
for (var i = 0; i<framesLength; i++) {
addFrame( frames[i] );
self.postMessage({
type: "progress",
data: Math.round( (i+1)/framesLength*100 )
});
}
// Finish
var string = '';
for ( var i = 0, l = gif.end(); i < l; i ++ ) {
string += String.fromCharCode( buffer[ i ] );
}
self.postMessage({
type: "gif",
data: string,
frameCount: framesLength,
encodeTime: Math.round( (Date.now()-startTime)/10 ) / 100
});
};
</code></pre>
<p>And all of <a href="https://github.com/antimatter15/jsgif/blob/master/NeuQuant.js" rel="nofollow noreferrer">NeuQuant.js</a>:</p>
<pre class="lang-js prettyprint-override"><code>/*
* NeuQuant Neural-Net Quantization Algorithm
* ------------------------------------------
*
* Copyright (c) 1994 Anthony Dekker
*
* NEUQUANT Neural-Net quantization algorithm by Anthony Dekker, 1994. See
* "Kohonen neural networks for optimal colour quantization" in "Network:
* Computation in Neural Systems" Vol. 5 (1994) pp 351-367. for a discussion of
* the algorithm.
*
* Any party obtaining a copy of these files from the author, directly or
* indirectly, is granted, free of charge, a full and unrestricted irrevocable,
* world-wide, paid up, royalty-free, nonexclusive right and license to deal in
* this software and documentation files (the "Software"), including without
* limitation the rights to use, copy, modify, merge, publish, distribute,
* sublicense, and/or sell copies of the Software, and to permit persons who
* receive copies from any such party to do so, with the only requirement being
* that this copyright notice remain intact.
*/
/*
* This class handles Neural-Net quantization algorithm
* @author Kevin Weiner (original Java version - kweiner@fmsware.com)
* @author Thibault Imbert (AS3 version - bytearray.org)
* @version 0.1 AS3 implementation
*/
//import flash.utils.ByteArray;
NeuQuant = function()
{
var exports = {};
/*private_static*/ var netsize/*int*/ = 256; /* number of colours used */
/* four primes near 500 - assume no image has a length so large */
/* that it is divisible by all four primes */
/*private_static*/ var prime1/*int*/ = 499;
/*private_static*/ var prime2/*int*/ = 491;
/*private_static*/ var prime3/*int*/ = 487;
/*private_static*/ var prime4/*int*/ = 503;
/*private_static*/ var minpicturebytes/*int*/ = (3 * prime4);
/* minimum size for input image */
/*
* Program Skeleton ---------------- [select samplefac in range 1..30] [read
* image from input file] pic = (unsigned char*) malloc(3*width*height);
* initnet(pic,3*width*height,samplefac); learn(); unbiasnet(); [write output
* image header, using writecolourmap(f)] inxbuild(); write output image using
* inxsearch(b,g,r)
*/
/*
* Network Definitions -------------------
*/
/*private_static*/ var maxnetpos/*int*/ = (netsize - 1);
/*private_static*/ var netbiasshift/*int*/ = 4; /* bias for colour values */
/*private_static*/ var ncycles/*int*/ = 100; /* no. of learning cycles */
/* defs for freq and bias */
/*private_static*/ var intbiasshift/*int*/ = 16; /* bias for fractions */
/*private_static*/ var intbias/*int*/ = (1 << intbiasshift);
/*private_static*/ var gammashift/*int*/ = 10; /* gamma = 1024 */
/*private_static*/ var gamma/*int*/ = (1 << gammashift);
/*private_static*/ var betashift/*int*/ = 10;
/*private_static*/ var beta/*int*/ = (intbias >> betashift); /* beta = 1/1024 */
/*private_static*/ var betagamma/*int*/ = (intbias << (gammashift - betashift));
/* defs for decreasing radius factor */
/*private_static*/ var initrad/*int*/ = (netsize >> 3); /*
* for 256 cols, radius
* starts
*/
/*private_static*/ var radiusbiasshift/*int*/ = 6; /* at 32.0 biased by 6 bits */
/*private_static*/ var radiusbias/*int*/ = (1 << radiusbiasshift);
/*private_static*/ var initradius/*int*/ = (initrad * radiusbias); /*
* and
* decreases
* by a
*/
/*private_static*/ var radiusdec/*int*/ = 30; /* factor of 1/30 each cycle */
/* defs for decreasing alpha factor */
/*private_static*/ var alphabiasshift/*int*/ = 10; /* alpha starts at 1.0 */
/*private_static*/ var initalpha/*int*/ = (1 << alphabiasshift);
/*private*/ var alphadec/*int*/ /* biased by 10 bits */
/* radbias and alpharadbias used for radpower calculation */
/*private_static*/ var radbiasshift/*int*/ = 8;
/*private_static*/ var radbias/*int*/ = (1 << radbiasshift);
/*private_static*/ var alpharadbshift/*int*/ = (alphabiasshift + radbiasshift);
/*private_static*/ var alpharadbias/*int*/ = (1 << alpharadbshift);
/*
* Types and Global Variables --------------------------
*/
/*private*/ var thepicture/*ByteArray*//* the input image itself */
/*private*/ var lengthcount/*int*/; /* lengthcount = H*W*3 */
/*private*/ var samplefac/*int*/; /* sampling factor 1..30 */
// typedef int pixel[4]; /* BGRc */
/*private*/ var network/*Array*/; /* the network itself - [netsize][4] */
/*protected*/ var netindex/*Array*/ = new Array();
/* for network lookup - really 256 */
/*private*/ var bias/*Array*/ = new Array();
/* bias and freq arrays for learning */
/*private*/ var freq/*Array*/ = new Array();
/*private*/ var radpower/*Array*/ = new Array();
var NeuQuant = exports.NeuQuant = function NeuQuant(thepic/*ByteArray*/, len/*int*/, sample/*int*/)
{
var i/*int*/;
var p/*Array*/;
thepicture = thepic;
lengthcount = len;
samplefac = sample;
network = new Array(netsize);
for (i = 0; i < netsize; i++)
{
network[i] = new Array(4);
p = network[i];
p[0] = p[1] = p[2] = (i << (netbiasshift + 8)) / netsize;
freq[i] = intbias / netsize; /* 1/netsize */
bias[i] = 0;
}
}
var colorMap = function colorMap()/*ByteArray*/
{
var map/*ByteArray*/ = [];
var index/*Array*/ = new Array(netsize);
for (var i/*int*/ = 0; i < netsize; i++)
index[network[i][3]] = i;
var k/*int*/ = 0;
for (var l/*int*/ = 0; l < netsize; l++) {
var j/*int*/ = index[l];
map[k++] = (network[j][0]);
map[k++] = (network[j][1]);
map[k++] = (network[j][2]);
}
return map;
}
/*
* Insertion sort of network and building of netindex[0..255] (to do after
* unbias)
* -------------------------------------------------------------------------------
*/
var inxbuild = function inxbuild()/*void*/
{
var i/*int*/;
var j/*int*/;
var smallpos/*int*/;
var smallval/*int*/;
var p/*Array*/;
var q/*Array*/;
var previouscol/*int*/
var startpos/*int*/
previouscol = 0;
startpos = 0;
for (i = 0; i < netsize; i++)
{
p = network[i];
smallpos = i;
smallval = p[1]; /* index on g */
/* find smallest in i..netsize-1 */
for (j = i + 1; j < netsize; j++)
{
q = network[j];
if (q[1] < smallval)
{ /* index on g */
smallpos = j;
smallval = q[1]; /* index on g */
}
}
q = network[smallpos];
/* swap p (i) and q (smallpos) entries */
if (i != smallpos)
{
j = q[0];
q[0] = p[0];
p[0] = j;
j = q[1];
q[1] = p[1];
p[1] = j;
j = q[2];
q[2] = p[2];
p[2] = j;
j = q[3];
q[3] = p[3];
p[3] = j;
}
/* smallval entry is now in position i */
if (smallval != previouscol)
{
netindex[previouscol] = (startpos + i) >> 1;
for (j = previouscol + 1; j < smallval; j++) netindex[j] = i;
previouscol = smallval;
startpos = i;
}
}
netindex[previouscol] = (startpos + maxnetpos) >> 1;
for (j = previouscol + 1; j < 256; j++) netindex[j] = maxnetpos; /* really 256 */
}
/*
* Main Learning Loop ------------------
*/
var learn = function learn()/*void*/
{
var i/*int*/;
var j/*int*/;
var b/*int*/;
var g/*int*/
var r/*int*/;
var radius/*int*/;
var rad/*int*/;
var alpha/*int*/;
var step/*int*/;
var delta/*int*/;
var samplepixels/*int*/;
var p/*ByteArray*/;
var pix/*int*/;
var lim/*int*/;
if (lengthcount < minpicturebytes) samplefac = 1;
alphadec = 30 + ((samplefac - 1) / 3);
p = thepicture;
pix = 0;
lim = lengthcount;
samplepixels = lengthcount / (3 * samplefac);
delta = samplepixels / ncycles;
alpha = initalpha;
radius = initradius;
rad = radius >> radiusbiasshift;
if (rad <= 1) rad = 0;
for (i = 0; i < rad; i++) radpower[i] = alpha * (((rad * rad - i * i) * radbias) / (rad * rad));
if (lengthcount < minpicturebytes) step = 3;
else if ((lengthcount % prime1) != 0) step = 3 * prime1;
else
{
if ((lengthcount % prime2) != 0) step = 3 * prime2;
else
{
if ((lengthcount % prime3) != 0) step = 3 * prime3;
else step = 3 * prime4;
}
}
i = 0;
while (i < samplepixels)
{
b = (p[pix + 0] & 0xff) << netbiasshift;
g = (p[pix + 1] & 0xff) << netbiasshift;
r = (p[pix + 2] & 0xff) << netbiasshift;
j = contest(b, g, r);
altersingle(alpha, j, b, g, r);
if (rad != 0) alterneigh(rad, j, b, g, r); /* alter neighbours */
pix += step;
if (pix >= lim) pix -= lengthcount;
i++;
if (delta == 0) delta = 1;
if (i % delta == 0)
{
alpha -= alpha / alphadec;
radius -= radius / radiusdec;
rad = radius >> radiusbiasshift;
if (rad <= 1) rad = 0;
for (j = 0; j < rad; j++) radpower[j] = alpha * (((rad * rad - j * j) * radbias) / (rad * rad));
}
}
}
/*
** Search for BGR values 0..255 (after net is unbiased) and return colour
* index
* ----------------------------------------------------------------------------
*/
var map = exports.map = function map(b/*int*/, g/*int*/, r/*int*/)/*int*/
{
var i/*int*/;
var j/*int*/;
var dist/*int*/
var a/*int*/;
var bestd/*int*/;
var p/*Array*/;
var best/*int*/;
bestd = 1000; /* biggest possible dist is 256*3 */
best = -1;
i = netindex[g]; /* index on g */
j = i - 1; /* start at netindex[g] and work outwards */
while ((i < netsize) || (j >= 0))
{
if (i < netsize)
{
p = network[i];
dist = p[1] - g; /* inx key */
if (dist >= bestd) i = netsize; /* stop iter */
else
{
i++;
if (dist < 0) dist = -dist;
a = p[0] - b;
if (a < 0) a = -a;
dist += a;
if (dist < bestd)
{
a = p[2] - r;
if (a < 0) a = -a;
dist += a;
if (dist < bestd)
{
bestd = dist;
best = p[3];
}
}
}
}
if (j >= 0)
{
p = network[j];
dist = g - p[1]; /* inx key - reverse dif */
if (dist >= bestd) j = -1; /* stop iter */
else
{
j--;
if (dist < 0) dist = -dist;
a = p[0] - b;
if (a < 0) a = -a;
dist += a;
if (dist < bestd)
{
a = p[2] - r;
if (a < 0)a = -a;
dist += a;
if (dist < bestd)
{
bestd = dist;
best = p[3];
}
}
}
}
}
return (best);
}
var process = exports.process = function process()/*ByteArray*/
{
learn();
unbiasnet();
inxbuild();
return colorMap();
}
/*
* Unbias network to give byte values 0..255 and record position i to prepare
* for sort
* -----------------------------------------------------------------------------------
*/
var unbiasnet = function unbiasnet()/*void*/
{
var i/*int*/;
var j/*int*/;
for (i = 0; i < netsize; i++)
{
network[i][0] >>= netbiasshift;
network[i][1] >>= netbiasshift;
network[i][2] >>= netbiasshift;
network[i][3] = i; /* record colour no */
}
}
/*
* Move adjacent neurons by precomputed alpha*(1-((i-j)^2/[r]^2)) in
* radpower[|i-j|]
* ---------------------------------------------------------------------------------
*/
var alterneigh = function alterneigh(rad/*int*/, i/*int*/, b/*int*/, g/*int*/, r/*int*/)/*void*/
{
var j/*int*/;
var k/*int*/;
var lo/*int*/;
var hi/*int*/;
var a/*int*/;
var m/*int*/;
var p/*Array*/;
lo = i - rad;
if (lo < -1) lo = -1;
hi = i + rad;
if (hi > netsize) hi = netsize;
j = i + 1;
k = i - 1;
m = 1;
while ((j < hi) || (k > lo))
{
a = radpower[m++];
if (j < hi)
{
p = network[j++];
try {
p[0] -= (a * (p[0] - b)) / alpharadbias;
p[1] -= (a * (p[1] - g)) / alpharadbias;
p[2] -= (a * (p[2] - r)) / alpharadbias;
} catch (e/*Error*/) {} // prevents 1.3 miscompilation
}
if (k > lo)
{
p = network[k--];
try
{
p[0] -= (a * (p[0] - b)) / alpharadbias;
p[1] -= (a * (p[1] - g)) / alpharadbias;
p[2] -= (a * (p[2] - r)) / alpharadbias;
} catch (e/*Error*/) {}
}
}
}
/*
* Move neuron i towards biased (b,g,r) by factor alpha
* ----------------------------------------------------
*/
var altersingle = function altersingle(alpha/*int*/, i/*int*/, b/*int*/, g/*int*/, r/*int*/)/*void*/
{
/* alter hit neuron */
var n/*Array*/ = network[i];
n[0] -= (alpha * (n[0] - b)) / initalpha;
n[1] -= (alpha * (n[1] - g)) / initalpha;
n[2] -= (alpha * (n[2] - r)) / initalpha;
}
/*
* Search for biased BGR values ----------------------------
*/
var contest = function contest(b/*int*/, g/*int*/, r/*int*/)/*int*/
{
/* finds closest neuron (min dist) and updates freq */
/* finds best neuron (min dist-bias) and returns position */
/* for frequently chosen neurons, freq[i] is high and bias[i] is negative */
/* bias[i] = gamma*((1/netsize)-freq[i]) */
var i/*int*/;
var dist/*int*/;
var a/*int*/;
var biasdist/*int*/;
var betafreq/*int*/;
var bestpos/*int*/;
var bestbiaspos/*int*/;
var bestd/*int*/;
var bestbiasd/*int*/;
var n/*Array*/;
bestd = ~(1 << 31);
bestbiasd = bestd;
bestpos = -1;
bestbiaspos = bestpos;
for (i = 0; i < netsize; i++)
{
n = network[i];
dist = n[0] - b;
if (dist < 0) dist = -dist;
a = n[1] - g;
if (a < 0) a = -a;
dist += a;
a = n[2] - r;
if (a < 0) a = -a;
dist += a;
if (dist < bestd)
{
bestd = dist;
bestpos = i;
}
biasdist = dist - ((bias[i]) >> (intbiasshift - netbiasshift));
if (biasdist < bestbiasd)
{
bestbiasd = biasdist;
bestbiaspos = i;
}
betafreq = (freq[i] >> betashift);
freq[i] -= betafreq;
bias[i] += (betafreq << gammashift);
}
freq[bestpos] += beta;
bias[bestpos] -= betagamma;
return (bestbiaspos);
}
NeuQuant.apply(this, arguments);
return exports;
}
</code></pre>
|
<p>JavaScript code seems to ignore that C truncates the results of the operations with decimal numbers before assign them to integer variables. So, <code>int i = 5 / 2;</code> is <code>2</code> to C, but <code>var i = 5 / 2;</code> is <code>2.5</code> to JavaScript.</p>
<p>Said that, change this line:</p>
<pre><code>delta = samplepixels / ncycles;
</code></pre>
<p>to:</p>
<pre><code>delta = (samplepixels / ncycles) | 0;
</code></pre>
<p>This solves the issue, but it's not clear to me if this change solves all the possible integer conversion problems, or only the one exposed in the question.</p>
<p>Note that I have used the bitwise OR operator to truncate the result. This is a classic way to truncate a number in JavaScript, because bitwise operators treat their operands as integers of 32 bits.</p>
| 1,515
|
implement quantization
|
Is Elu int8 quantisation working on Tensorflow Lite?
|
https://stackoverflow.com/questions/67774808/is-elu-int8-quantisation-working-on-tensorflow-lite
|
<p><em>Context</em> :<br />
I would like to run inferencing of a DL-model on an Arduino and, since I don't have much memory available, I need to post-training <strong>int8-quantize</strong> my model.<br />
But the <strong>quantization</strong> of my model <strong>doesn't seem to be working</strong>, and it seems to be linked to the <strong>Elu activations functions</strong> in the model.<br />
Indeed, I get <strong>no error</strong> during both the conversion and the quantization of the model on Python and the inferencing on Arduino, but <strong>the necessary size for the model on the Arduino remains the same than without quantization</strong>.</p>
<p><em>What I tried</em> :</p>
<ul>
<li>I retrained a model in which I changed the Elu for <strong>Relu</strong> activation functions. Then quantization <strong>works</strong> : thanks to the line : <code>tflInterpreter->arena_used_bytes()</code> on Arduino, I can see that quantization helped me to reduce the necessary size for the model <strong>by 3</strong>.</li>
<li>I analysed the model (quantized, with Elu) on the Netron App and I realised that there are steps of <strong>de-quantization and re-quantization</strong> before and after each call of Elu function : <a href="https://i.sstatic.net/S8ECt.png" rel="nofollow noreferrer">model de-quantize and re-quantize</a>. I don't understand why is this doing so, when it doesn't append with Relu functions.</li>
<li>Finally, I found this commit on Tensorflow Git, which made me believe that int8 quantization for Elu <strong>is implemented</strong> : <a href="https://github.com/tensorflow/tensorflow/commit/918f876bf812fd744151fea29b2df4aa18acfa8f" rel="nofollow noreferrer">Commit for Elu int8 quantization TF</a>. Nevertheless, they mentioned a LUT approach, which I don't understand and might (?) be linked to the troubles I am facing.</li>
</ul>
<p><em>Context</em> :</p>
<ul>
<li>TF 2.5.</li>
<li>Training, conversion and quantisation on Colab</li>
<li>Arduino with TFLite version 2.5</li>
</ul>
<p>Does anyone face the same king of troubles for quantization of model containing Elu ? Do you have any idea of how to solve this problem ?</p>
<p>Thank you really much !</p>
| 1,516
|
|
implement quantization
|
torch Parameter grad return none
|
https://stackoverflow.com/questions/74387343/torch-parameter-grad-return-none
|
<p>I want to implement learned size quantization algorithm. And I create a quante Linear layer</p>
<pre class="lang-py prettyprint-override"><code>class QLinear(nn.Module):
def __init__(self, input_dim, out_dim, bits=8):
super(QLinear, self).__init__()
# create a tensor requires_grad=True
self.up = 2 ** bits - 1
self.down = 0
self.fc = nn.Linear(input_dim, out_dim)
weight = self.fc.weight.data
self.scale = nn.Parameter(torch.Tensor((torch.max(weight) - torch.min(weight)) / (self.up - self.down)), requires_grad=True)
self.zero_point = nn.Parameter(torch.Tensor(self.down - (torch.min(weight) / self.scale).round()), requires_grad=True)
def forward(self, x):
weight = self.fc.weight
quant_weight = (round_ste(weight / self.scale) + self.zero_point)
quant_weight = torch.clamp(quant_weight, self.down, self.up)
dequant_weight = ((quant_weight - self.zero_point) * self.scale)
self.fc.weight.data = dequant_weight
return self.fc(x)
class QNet(nn.Module):
def __init__(self):
super(QNet, self).__init__()
self.fc1 = QLinear(28 * 28, 100)
self.fc2 = QLinear(100, 10)
def forward(self, x):
x = x.view(-1, 28 * 28)
x = F.relu(self.fc1(x))
x = self.fc2(x)
x = F.softmax(x)
return x
</code></pre>
<p>when I train this network,scale's grad always return None. Why this happen and how can i solve it?</p>
|
<p>The issue is that you are passing <code>dequant_weight</code> through data attribute of your parameter which ends up not being registered by autograd. A simple alternative would be to handle <code>weight</code> as a <a href="https://pytorch.org/docs/stable/generated/torch.nn.parameter.Parameter.html" rel="nofollow noreferrer"><code>nn.Parameter</code></a> and apply a linear operator manually in the forward definition directly with the computed weight <code>dequant_weight</code>.</p>
<p>Here is a minimal example that should work:</p>
<pre><code>class QLinear(nn.Module):
def __init__(self, input_dim, out_dim, bits=8):
super().__init__()
self.up = 2 ** bits - 1
self.down = 0
self.weight = nn.Parameter(torch.rand(out_dim, input_dim))
self.scale = nn.Parameter(
torch.Tensor((self.weight.max() - self.weight.min()) / (self.up - self.down)))
self.zero_point = nn.Parameter(
torch.Tensor(self.down - (self.weight.min() / self.scale).round()))
def forward(self, x):
quant_weight = (torch.round(self.weight / self.scale) + self.zero_point)
quant_weight = torch.clamp(quant_weight, self.down, self.up)
dequant_weight = ((quant_weight - self.zero_point) * self.scale)
return F.linear(x, dequant_weight)
</code></pre>
<hr />
<p>Side notes:</p>
<ul>
<li><p><code>nn.Parameter</code> requires gradient computation by default (no need to provide <code>requires_grad=True</code>.</p>
</li>
<li><p>Additionally you can reformat <code>QNet</code> by inheriting from <a href="https://pytorch.org/docs/stable/generated/torch.nn.Sequential.html" rel="nofollow noreferrer"><code>nn.Sequential</code></a> to avoid boilerplate code:</p>
<pre><code>class QNet(nn.Sequential):
def __init__(self):
super().__init__(nn.Flatten(),
QLinear(28 * 28, 100),
nn.ReLU(),
QLinear(100, 10),
nn.Softmax())
</code></pre>
</li>
</ul>
| 1,517
|
implement quantization
|
How to remove "infinite" while loop to improve MATLAB code?
|
https://stackoverflow.com/questions/66075396/how-to-remove-infinite-while-loop-to-improve-matlab-code
|
<p>I am implementing a logarithmic quantizer and what I would like to do is to optimize the code as much as possible. The precise point where I would like to make a change is the last <code>else</code> statement where the equation to be implemented is:</p>
<p><code>q(u) = u_i</code> if <code>u_i/(1+step) < u <= u_i/(1-step)</code><br />
<code>u_i = p^(1-i)u_o</code> for <code>i=1,2,...</code></p>
<p>The parameters <code>p, step, u_o</code> are some constants to be chosen.</p>
<p>More information regarding the quantizer can be found at this paper: <a href="https://ieeexplore.ieee.org/document/6760767" rel="nofollow noreferrer">Adaptive Backstepping Control of Uncertain Nonlinear Systems with Input Quantization</a>.</p>
<p>In order to code a function to implement it in MATLAB, I wrote the following piece of code:</p>
<pre><code>function q_u = logarithmic_hysteretic_quantizer(u,step,u_min)
u_o = u_min*(1+step);
p = (1-step)/(1+step);
if u < 0
q_u = -logarithmic_hysteretic_quantizer(-u,step,u_min);
elseif ( (u >= 0) && (u <= u_o/(1+step)) )
q_u = 0;
else
i = 1;
while (1)
u_i = p^(1-i) * u_o;
if ( (u > u_i/(1+step)) && (u <= u_i/(1-step)) )
q_u = u_i;
break;
end
i = i + 1;
end
end
end
</code></pre>
<p>Now, my issue is to improve the code as much as I can. For example, the <code>while(1)</code> loop, which codes the different quantization levels, is something that could probably go away and be replaced. Any thoughts would be really appreciated.</p>
|
<p>Assuming <code>u_min>0</code> and <code>0<p<1</code>, you can simplify <code>(u > u_i/(1+step)) && (u <= u_i/(1-step))</code> to:</p>
<pre><code>u/u_min > p^(1-i) && p^-i >= u/u_min
</code></pre>
<p>Which since <code>log</code> is monotonic, simplifies to</p>
<pre><code>-log(u/u_min)/log(p) > i-1 && i >= -log(u/u_min)/log(p)
</code></pre>
<p>Which makes the while loop equivalent to simply</p>
<pre><code>i = floor(-log(u/u_min)/log(p));
q_u = p^(1-i) * u_o;
</code></pre>
<p>Furthermore, <code>(u >= 0)</code> in the <code>elseif</code> branch is always true, and you probably can get rid of the <code>u<0</code> test, by replacing <code>u</code> by <code>abs(u)</code> at the right places.</p>
| 1,518
|
implement quantization
|
What is the condition to stop splitting data in Non-Uniform Quantizer?
|
https://stackoverflow.com/questions/41026017/what-is-the-condition-to-stop-splitting-data-in-non-uniform-quantizer
|
<p>I'm trying to implement a non-uniform quantizer with N-level of quantization.
I have already done some work and it works, the problem is it goes into infinite loop when N(the number of levels) exceeds "4".</p>
<p>If anyone can point out any hints to know where the wrong is, I'd appreciate it.</p>
<pre><code>public static Vector<Integer> split(Vector <Integer> image,float average,int n)
{
float lowerAverage = average - 1;
float upperAverage = average + 1;
Vector<Float> averages = new Vector<Float>();
Vector <Integer> leftData = new Vector <Integer>();
Vector <Integer> rightData = new Vector <Integer>();
averages.add(lowerAverage);
averages.add(upperAverage);
//FIND ALL AVERAGES
while (averages.size()<n)
{
//I THINK THE PROBLEM HAPPENS HERE AS IT KEEP PRINTING "loop"
System.out.println("loop");
for (int i = 0; i < image.size(); i++)
{
if (Math.abs(image.get(i)-lowerAverage) <= Math.abs(image.get(i)-upperAverage))
{
leftData.add(image.get(i));
}
else
{
rightData.add(image.get(i));
}
}
lowerAverage = average(leftData) - 1;
upperAverage = average (leftData) + 1;
averages.removeAllElements();
averages.add(lowerAverage);
averages.add(upperAverage);
lowerAverage = average(rightData) - 1;
upperAverage = average (rightData) + 1;
averages.add(lowerAverage);
averages.add(upperAverage);
}
//*****************************************************************************************
//CREATE DATASETS WITH NUMBER == AVERAGES.SIZE()
Vector <DataSet> v = new Vector <DataSet>();
for (int i = 0; i < averages.size(); i++) {
DataSet temp = new DataSet();
temp.setName(averages.get(i));
v.add(temp);
}
//*****************************************************************************************
//SPLIT ORIGINAL DATA ACCORDING TO AVERAGES
float name;
for (int i = 0; i < image.size(); i++)
{
float min =Math.abs(image.get(i)-averages.get(0));
name = averages.get(0);
for (int j = 1; j < averages.size(); j++)
{
if (Math.abs(image.get(i)-averages.get(j)) < min)
{
min = Math.abs(image.get(i)-averages.get(j));
name = averages.get(j);
}
}
getDataset(v, name).addData(image.get(i));
}
//*****************************************************************************************
//CALCULATE EACH DATASET AVERAGE
for (int i = 0; i < v.size(); i++)
{
v.get(i).UpdateAverage();
}
//*****************************************************************************************
//THIS IS JUST FOR TESTING
Vector<Integer> Qinv = new Vector<Integer>();
for (int i = 0; i < v.size(); i++)
{
Qinv.add(v.get(i).getAverage());
}
return Qinv;
}
</code></pre>
| 1,519
|
|
implement quantization
|
Is there an implementation of libjpeg in python?
|
https://stackoverflow.com/questions/9695896/is-there-an-implementation-of-libjpeg-in-python
|
<p>I am writing some python code that needs <a href="http://www.ijg.org/" rel="nofollow">libjpeg</a> . I searched for it on the Internet, and I couldn't find an implement of libjpeg in python. I would like to be able to access, DCT coefficient values, quantization tables, etc.</p>
<p>Thanks!</p>
|
<p>That would be the <a href="http://docs.python.org/library/jpeg.html" rel="nofollow"><code>jpeg</code></a> module. However, typically the <a href="http://www.pythonware.com/products/pil/" rel="nofollow">Python Imaging Library</a> is preferred for image manipulation.</p>
| 1,520
|
implement quantization
|
Is it possible to configure TFLite to return a model with bias quantized to int8?
|
https://stackoverflow.com/questions/63303255/is-it-possible-to-configure-tflite-to-return-a-model-with-bias-quantized-to-int8
|
<p>I'm working with Keras/Tensorflow to develop an ANN that will be deployed to a low-end MCU. For this purpose, I have quantized the original ANN using the post-training quantization mechanism offered by Tensorflow Lite. If the weights are indeed quantized to int8, biases were converted from float to int32. Considering that I pretend to implement this ANN in CMSIS-NN, this is a problem as they only support int8 and int16 data.</p>
<p>Is it possible to configure TF Lite to also quantize biases to int8? Below follows the code I am executing:</p>
<pre><code>def quantizeToInt8(representativeDataset):
# Cast the dataset to float32
data = tf.cast(representativeDataset, tf.float32)
data = tf.data.Dataset.from_tensor_slices((data)).batch(1)
# Generator function that returns one data point per iteration
def representativeDatasetGen():
for inputValue in data:
yield[inputValue]
# ANN quantization
model = tf.keras.models.load_model("C:/Users/miguel/Documents/Universidade/PhD/Code_Samples/TensorFlow/originalModel.h5")
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.representative_dataset = representativeDatasetGen
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
converter.target_spec.supported_types = [tf.int8]
converter.inference_type = tf.int8
converter.inference_input_type = tf.int8 # or tf.uint8
converter.inference_output_type = tf.int8 # or tf.uint8
tflite_quant_model = converter.convert()
return tflite_quant_model
</code></pre>
|
<p>From Comments</p>
<blockquote>
<p>It's not possible to configure <code>TFLite</code> to do that. <code>Biases</code> are
intentionally <code>int32 </code>otherwise the quantization accuracy would not be
good. In order to make this work, you'd have to add a new op or custom
op and then come up with a custom quantization tooling all together.(paraphrased from
Meghna Natraj).</p>
</blockquote>
| 1,521
|
implement quantization
|
How to create if else statement in a custom Keras layer
|
https://stackoverflow.com/questions/73369209/how-to-create-if-else-statement-in-a-custom-keras-layer
|
<p>I am trying to define a custom layer in Keras, where the data values are first quantized as -1, 0, or 1. Then, every -1 is transformed to 0. For example,
The input tensor is x = [-0.95, -0.85,0.1,0.9]. It will be quantized to x1 = [-1,-1,0,1]. Then, x2 is transformed to x3 = [0,0,0,1]. I have completed the quantization part. However, I don't know how to implement the if-else control flow to map -1 to 0. Thank you for any helpful suggestions.</p>
| 1,522
|
|
implement quantization
|
How to implement TF Lite inference in Python
|
https://stackoverflow.com/questions/61850203/how-to-implement-tf-lite-inference-in-python
|
<p>For research purposes, I'm trying to understand how TF Lite does its inference. I'm interested only in the software logic.</p>
<p>I'm using TensorFlow 2.1 and TensorFlow Model Optimization 0.3.0.</p>
<p>As an example, I use a very simple fully connected network:</p>
<pre><code>tf.keras.models.Sequential([
tf.keras.layers.Flatten(input_shape=(28, 28, 1)),
tf.keras.layers.Dense(10, activation=None)
])
</code></pre>
<p>I train the network on mnist with quantized aware training.</p>
<p>And then quantize the network with TF Lite:</p>
<pre><code>converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.representative_dataset = data_generator(ds_train)
quantized_tflite_model = converter.convert()
</code></pre>
<p>In order to make sure that I know what I'm doing I did 3 things:
I used TF to get outputs from the 32 bit model.
I used TF Lite to get outputs from the quantized model.
I implemented in Python the forward pass for the 32 bit model and compared its outputs to the previous 2.</p>
<p>Now I'm trying to understand how to implement the forward pass of the quantized model.</p>
<p>Using interpreter.get_tensor_details(), I get the following output:</p>
<pre><code>{'name': 'Identity', 'index': 0, 'shape': array([ 1, 10]), 'dtype': <class 'numpy.float32'>, 'quantization': (0.0, 0)}
{'name': 'flatten_input_int8', 'index': 1, 'shape': array([ 1, 28, 28, 1]), 'dtype': <class 'numpy.int8'>, 'quantization': (0.003921568859368563, -128)}
{'name': 'sequential/quant_dense/BiasAdd', 'index': 2, 'shape': array([ 1, 10]), 'dtype': <class 'numpy.int8'>, 'quantization': (0.22868551313877106, 49)}
{'name': 'sequential/quant_dense/LastValueQuant/FakeQuantWithMinMaxVars/transpose', 'index': 3, 'shape': array([ 10, 784]), 'dtype': <class 'numpy.int8'>, 'quantization': (0.01087072491645813, 0)}
{'name': 'sequential/quant_dense/MatMul_bias', 'index': 4, 'shape': array([10]), 'dtype': <class 'numpy.int32'>, 'quantization': (4.263029768480919e-05, 0)}
{'name': 'sequential/quant_dense/BiasAdd_float', 'index': 5, 'shape': array([ 1, 10]), 'dtype': <class 'numpy.float32'>, 'quantization': (0.0, 0)}
{'name': 'flatten_input', 'index': 6, 'shape': array([ 1, 28, 28, 1]), 'dtype': <class 'numpy.float32'>, 'quantization': (0.0, 0)}
</code></pre>
<p>I'm using this paper as a reference: <a href="https://arxiv.org/pdf/1712.05877.pdf" rel="nofollow noreferrer">https://arxiv.org/pdf/1712.05877.pdf</a>
I also read this page: <a href="https://www.tensorflow.org/lite/performance/quantization_spec" rel="nofollow noreferrer">https://www.tensorflow.org/lite/performance/quantization_spec</a></p>
<p>My current implementation goes like this:</p>
<pre><code>def quantization_params(index):
return tensor_details[index]['quantization'][0], tensor_details[index]['quantization'][1]
image = get_single_test_image(show_image=False)
# #### Convert input image from float32 to int8 ####
q_scale, q_zero = quantization_params(index=1)
x = image / q_scale + q_zero
# #### Flatten input ####
x = x.flatten()
# #### Dense layer ####
kernel, bias = tflite_model.interpreter.get_tensor(3), tflite_model.interpreter.get_tensor(4)
s_input, z_input = quantization_params(index=1)
s_kernel, z_kernel = quantization_params(index=3)
s_output, z_output = quantization_params(index=4)
M = s_input * s_kernel
quantized_multiplier, right_shift = quantize_multiplier_smaller_than_one(M)
dense_output = np.zeros((kernel.shape[0],), dtype=np.int32)
for i in range(dense_output.shape[0]):
for j in range(kernel.shape[1]):
dense_output[i] += int((x[j] + z_input) * (kernel[i, j] + z_kernel))
x = dense_output + bias
x = np.right_shift(x * quantized_multiplier, right_shift)
</code></pre>
<p>the function quantize_multiplier_smaller_than_one is my Python implementation for the C function here: <a href="https://github.com/google/gemmlowp/blob/master/doc/quantization_example.cc" rel="nofollow noreferrer">https://github.com/google/gemmlowp/blob/master/doc/quantization_example.cc</a></p>
<p>So my questions here are, is this the correct approach?
I'm definitely missing some calculation here, what is it?
And also, when I have a bigger network, how do I know how to systematically use the correct indexes to pull the quantization params for each layer.</p>
<p>Many thanks for any advice.</p>
|
<p>At last, I solved this issues by digging into TensorFlow/Lite code.
I found the relevant code and modified it, so it printed all the relevant info that I needed into text files. From there I could parse everything in Python and run a Pythonic version of the cpp logic.</p>
<p>In case someone will want to try and do the same, in order to build the CPP solution go to <a href="https://www.tensorflow.org/install/source" rel="nofollow noreferrer">build from source</a></p>
<p>The entry point of a sample app is here: <a href="https://github.com/tensorflow/tensorflow/tree/master/tensorflow/lite/examples/minimal" rel="nofollow noreferrer">https://github.com/tensorflow/tensorflow/tree/master/tensorflow/lite/examples/minimal</a></p>
<p>And for example, the convolution reference code is here: <a href="https://github.com/tensorflow/tensorflow/blob/master/tensorflow/lite/kernels/internal/reference/integer_ops/conv.h" rel="nofollow noreferrer">https://github.com/tensorflow/tensorflow/blob/master/tensorflow/lite/kernels/internal/reference/integer_ops/conv.h</a></p>
<p>Enjoy (not really) </p>
| 1,523
|
implement quantization
|
Wildly different quantization performance on tensorflow-lite conversion of keras-trained DenseNet models
|
https://stackoverflow.com/questions/53050923/wildly-different-quantization-performance-on-tensorflow-lite-conversion-of-keras
|
<p>I have two models that I have trained using Keras. The two models use the same architecture (the DenseNet169 implementation from <code>keras_applications.densenet</code> package), however they each have a different number of target classes (80 in one case, 200 in the other case).</p>
<ul>
<li><p>Converting both models to .pb format works just fine (identical performance in inference). I use the <code>keras_to_tensorflow</code> utility found at <a href="https://github.com/amir-abdi/keras_to_tensorflow" rel="nofollow noreferrer">https://github.com/amir-abdi/keras_to_tensorflow</a></p></li>
<li><p>Converting both models to .tflite format using TOCO works just fine (again, identical performance in inference).</p></li>
<li><p>Converting the 80-class model to .tflite using quantization in TOCO works reasonably well (<1% drop in top 3 accuracy).</p></li>
<li><p>Converting the 200-class model to .tflite using quantization in TOCO goes off the rails (~30% drop in top 3 accuracy).</p></li>
</ul>
<p>I'm using an identical command-line to TOCO for both of the models:</p>
<p><code>toco --graph_def_file frozen_graph.pb \
--output_file quantized_graph.tflite \
--inference_type FLOAT \
--inference_input_type FLOAT \
--output_format TFLITE \
--input_arrays input_1 \
--output_arrays output_node0 \
--quantize True</code></p>
<p>My tensorflow version is 1.11.0 (installed via pip on macOS Mojave, although I have also tried the same command/environment on the Ubuntu machine I use for training with identical results).</p>
<p>I'm at a complete loss as to why the accuracy of inference is so drastically affected for one model and not the other. This holds true for many different trainings of the same two architecture/target class combinations. I feel like I must be missing something, but I'm baffled.</p>
|
<p><em>This was intended to be just a small sneaky comment since i'm not sure if this can help, but then it got so long that I decided to make it an answer...</em></p>
<hr>
<p><strong>My wild guess</strong> is that the accuracy drop may be caused by the variance of the output of your network. After quantization (btw, tensorflow uses <a href="https://heartbeat.fritz.ai/8-bit-quantization-and-tensorflow-lite-speeding-up-mobile-inference-with-low-precision-a882dfcafbbd" rel="nofollow noreferrer">fixed-point quantization</a>), you are playing with only <code>256</code> points (8 bit) instead of the full dense range of <code>float32</code>.</p>
<p>On most of the blogs around the web, it is stated that the main assumption of <em>Quantization</em> is that weights and activations tends to lie in a small range of values. However, there is an implicit assumption that is less talked about in blogs and literature: <em>the activations of the network on a single sample should be decently spread across the quantized range</em>.</p>
<p>Consider the following scenario where the <strong>assumption holds place</strong> (a histogram of activations on single sample at specific layer, and the vertical lines are quantization points):
<a href="https://i.sstatic.net/WJDqQ.png" rel="nofollow noreferrer"><img src="https://i.sstatic.net/WJDqQ.png" alt="enter image description here"></a></p>
<p>Now consider the scenario where the <strong>second assumption is not true</strong>, but the first assumption can <strong>still hold place</strong> (the blue is overall value distribution, gray is for given sample, vertical strips are quantization points):</p>
<p><a href="https://i.sstatic.net/o173X.png" rel="nofollow noreferrer"><img src="https://i.sstatic.net/o173X.png" alt="enter image description here"></a></p>
<p>In the first scenario, the distribution for the given sample is covered well (with a lot of quant points). In the second, only 2 quant points. <strong>The similar thing can happen to your network as well:</strong> maybe for 80 classes it still have enough quantization points to distinguish, but with 200 classes we might not have enough...</p>
<blockquote>
<p>Hey, but it doesn't affect MobileNet with 1000 classes, and even MobileNetV2, which is residual?</p>
</blockquote>
<p>That's why I called it "a wild guess". Maybe MobileNet and MobileNetV2 does not have such a wide output variance as DenseNet. The former only have one input at each layer (which is already normalized by BN), while DenseNet have connections all over the places so it can have larger variance as well as sensitivity to small changes, and BN might not help as much.</p>
<hr>
<p>Now, try this checklist:</p>
<ul>
<li>Manually collect activation statistics of both 80 and 200 models on <em>TensorFlow</em>, not only the outputs but inner layers as well. Is the values focused in one area or it spreads out widely?</li>
<li>See if single-input activations of the <em>TensorFlow</em> model spreads out nicely, or we may have some issues with it concentrating in one place?</li>
<li><strong>Most importantly</strong>: see what are the outputs of the <em>Quantized TF-Lite</em> model? If there are problems with the variance as described above, here is where it will show itself the most.</li>
</ul>
<hr>
<p><strong>PS:</strong> please share your results as well, I think many will be interested in troubleshooting quantization issues :)</p>
| 1,524
|
implement quantization
|
OpenGL triangle degeneration after vertex shader?
|
https://stackoverflow.com/questions/37069477/opengl-triangle-degeneration-after-vertex-shader
|
<p>Referring to that <a href="https://stackoverflow.com/questions/34422774/opengl-degenerate-gl-triangles-sharing-same-vertices/">question</a>:</p>
<p>There are several ways to improve rendering speed for huge meshes. I tried the following implementations:</p>
<ol>
<li>Just render the mesh without any optimization or quantization.</li>
<li>I decided to quantize my mesh as a preprocessing step on the CPU and switch the LOD-level (= quantization-level) on runtime. I submit the whole vertex-data and I render with Drawcall(numberOfNotDegeneratedIndices). -> faster than (0)</li>
<li>My idea now: Do the whole quantization in the Vertex-Shader (all vertex-data is present for calculations and dynamic LOD-switching). Triangle degeneration should automatically happen after the vertex processing step. Drawcall(numberOfAllIndices) -> not really faster than (0)</li>
</ol>
<p>Methodes compared: The amount of vertex-data submitted is always the same. VS calls: (0) == (2) > (1)</p>
<p>So I was wondering why method (2) doesn't get any faster than (0) despite quantization and resulting triangle degeneration?</p>
<p>I would like to get more information why it behaves likes this and where the bottlenecks on the GPU could be.</p>
|
<p>I hate to bring up the obvious, but have you tried resizing your framebuffer to something absurd like 1x1 and confirming that the bottleneck is in-fact vertex processing?</p>
<p>Given no screenshot or anything to go by, I have to guess what the "huge" mesh you are trying to render looks like; I can think of a lot of scenarios where a huge mesh leads to massive overdraw, at which point you could actually be fillrate bound and using different LODs would make very little difference.</p>
<p>As funny as it sounds, you can also run into rasterization performance bottlenecks if you draw a lot of (potentially invisible) subpixel triangles. Many will never survive for shading because they do not satisfy coverage rules, but if you get enough tiny primitives all the way into the rasterization stage you do pay a penalty unrelated to vertex processing. LODs work great for solving that problem, so it is unlikely to be your problem here.</p>
| 1,525
|
implement quantization
|
Layer up_sampling2d:<class 'tensorflow.python.keras.layers.convolutional.UpSampling2D'> is not supported
|
https://stackoverflow.com/questions/61406595/layer-up-sampling2dclass-tensorflow-python-keras-layers-convolutional-upsampl
|
<p>I am trying to implement UNet for Semantic Segmentation that can run on Google Coral edgetpu. In order to do so, we need to have a quantized model that can be obtained using the tensorflow_model_optimization API.</p>
<p>But while using the API, there is a layer for UpSampling2D which is not supported by the <a href="https://www.tensorflow.org/model_optimization/guide/quantization/training_comprehensive_guide" rel="nofollow noreferrer">Quantization Aware API</a>. Here is the code to obtain a quantized model from a normal one as recommended.</p>
<pre><code>from image_segmentation_keras.keras_segmentation.models.unet import vgg_unet
import tensorflow_model_optimization as tfmot
model = vgg_unet(n_classes=4 , input_height=832, input_width=1216 )
quantize_model = tfmot.quantization.keras.quantize_model #q_aware stands for for quantization aware.
q_aware_model = quantize_model(model)
...
o = (Conv2D(512, (3, 3), padding='valid' , data_format=IMAGE_ORDERING))(o)
o = (BatchNormalization())(o)
o = Activation('relu')(o)
o = (UpSampling2D((2, 2), data_format=IMAGE_ORDERING))(o)
o = (concatenate([o, f3], axis=MERGE_AXIS))
o = (ZeroPadding2D((1, 1), data_format=IMAGE_ORDERING))(o)
...
Layer up_sampling2d:<class 'tensorflow.python.keras.layers.convolutional.UpSampling2D'> is not supported.You can quantize this layer by passing a `tfmot.quantization.keras.QuantizeConfig` instance to the `quantize_annotate_layer` API.
</code></pre>
<p>Following are the findings-</p>
<ul>
<li>I tried using the alternative to up_sampling2d Conv2DTranspose instead of upsampling but it looks like Conv2DTranspose is also not supported.</li>
<li><p><code>Layer conv2Dtranspose:<class 'tensorflow.python.keras.layers.convolutional.Conv2DTranspose'> is not supported.</code></p></li>
<li><p>Most of the <a href="https://github.com/google-coral/tflite/tree/master/python" rel="nofollow noreferrer">official example quantized models</a> of Edge TPU do not need upscaling of the image.E.g - Classification and Detection Models output is either a class or a number of bounding boxes with the respective classes.</p></li>
<li>Although there is an example edgetpu quantization model for segmentation- <a href="https://github.com/google-coral/edgetpu/blob/master/test_data/deeplabv3_mnv2_pascal_quant_edgetpu.tflite" rel="nofollow noreferrer">Deeplabv3 based quantized edgetpu segmentation</a>, there is no help regarding the architecture and how the upscaling has been solved.</li>
</ul>
<p>Any help in this regard will be greatly appreciated.</p>
| 1,526
|
|
implement quantization
|
How to reduce the number of colors in an image with OpenCV?
|
https://stackoverflow.com/questions/5906693/how-to-reduce-the-number-of-colors-in-an-image-with-opencv
|
<p>I have a set of image files, and I want to reduce the number of colors of them to 64. How can I do this with OpenCV?</p>
<p>I need this so I can work with a 64-sized image histogram.
I'm implementing CBIR techniques</p>
<p>What I want is color quantization to a 4-bit palette.</p>
|
<p>There are many ways to do it. The methods suggested by jeff7 are OK, but some drawbacks are:</p>
<ul>
<li>method 1 have parameters N and M, that you must choose, and you must also convert it to another colorspace.</li>
<li>method 2 answered can be very slow, since you should compute a 16.7 Milion bins histogram and sort it by frequency (to obtain the 64 higher frequency values)</li>
</ul>
<p>I like to use an algorithm based on the <strong>Most Significant Bits</strong> to use in a RGB color and convert it to a 64 color image. If you're using C/OpenCV, you can use something like the function below.</p>
<p>If you're working with gray-level images I recommed to use the LUT() function of the OpenCV 2.3, since it is faster. There is a tutorial on how to use LUT to reduce the number of colors. See: <a href="http://opencv.itseez.com/doc/tutorials/core/how_to_scan_images/how_to_scan_images.html">Tutorial: How to scan images, lookup tables...</a> However I find it more complicated if you're working with RGB images. </p>
<pre><code>void reduceTo64Colors(IplImage *img, IplImage *img_quant) {
int i,j;
int height = img->height;
int width = img->width;
int step = img->widthStep;
uchar *data = (uchar *)img->imageData;
int step2 = img_quant->widthStep;
uchar *data2 = (uchar *)img_quant->imageData;
for (i = 0; i < height ; i++) {
for (j = 0; j < width; j++) {
// operator XXXXXXXX & 11000000 equivalent to XXXXXXXX AND 11000000 (=192)
// operator 01000000 >> 2 is a 2-bit shift to the right = 00010000
uchar C1 = (data[i*step+j*3+0] & 192)>>2;
uchar C2 = (data[i*step+j*3+1] & 192)>>4;
uchar C3 = (data[i*step+j*3+2] & 192)>>6;
data2[i*step2+j] = C1 | C2 | C3; // merges the 2 MSB of each channel
}
}
}
</code></pre>
| 1,527
|
implement quantization
|
What is training and testing in image processing?
|
https://stackoverflow.com/questions/34577701/what-is-training-and-testing-in-image-processing
|
<p>I'm implementing color quantization based on <em>k-means clustering</em> method on some RGB images. Then, I will determine the performance the algorithm. I found some information about training and testing. As I understand, I should divide the samples of images for training and testing. </p>
<p>But I am confused about the terms training and testing. What does these mean ? And how to implement with a rank value ?</p>
|
<p>Training and testing are two common concepts in <em>machine learning</em>. Training and testing are more easily explained in the framework of <em>supervised learning</em>; where you have a training dataset for which you know both input data as well as additional attributes that you want to predict. Training consists in learning a relation between data and attributes from a fraction of the training dataset, and testing consists in testing predictions of this relation on another part of the dataset (since you know the prediction, you can compare the output of the relation and the real attributes). A good introductory tutorial using these concepts can be found on <a href="http://scikit-learn.org/stable/tutorial/basic/tutorial.html" rel="noreferrer">http://scikit-learn.org/stable/tutorial/basic/tutorial.html</a></p>
<p>However, clustering is a class of <em>unsupervised learning</em>, that is, you just have some input data (here, the RGB values of pixels, if I understand well), without any corresponding target values. Therefore, you can run a k-means clustering algorithm in order to find classes of pixels with similar colors, without the need to train and test the algorithm. </p>
<p>In image processing, training and testing is for example used for classifying pixels in order to segment different objects. A common example is to use a random forest classifier: the user selects pixels belonging to the different objects of interest (eg background and object), the classifier is trained on this set of pixels, and then the remainder of the pixels are attributed to one of the classes by the classifier. ilastik (<a href="http://ilastik.org/" rel="noreferrer">http://ilastik.org/</a>) is an example of software that performs interactive image classification and segmentation.</p>
<p>I don't know which programming language you're using, but k-means is already implemented in various libraries. For Python, both SciPy (<a href="http://docs.scipy.org/doc/scipy/reference/generated/scipy.cluster.vq.kmeans2.html#scipy.cluster.vq.kmeans2" rel="noreferrer">http://docs.scipy.org/doc/scipy/reference/generated/scipy.cluster.vq.kmeans2.html#scipy.cluster.vq.kmeans2</a>) and scikit-learn (<a href="http://scikit-learn.org/stable/modules/generated/sklearn.cluster.KMeans.html" rel="noreferrer">http://scikit-learn.org/stable/modules/generated/sklearn.cluster.KMeans.html</a>) have an implementation of K-means. Also note that, depending on your application, you may be interested in clustering pixels together using not only pixels values, but also spatial proximity of pixels. See for example the scikit-image gallery example <a href="http://scikit-image.org/docs/dev/auto_examples/plot_rag_mean_color.html" rel="noreferrer">http://scikit-image.org/docs/dev/auto_examples/plot_rag_mean_color.html</a></p>
| 1,528
|
implement quantization
|
Display dark 16-bit .tiff in Canvas
|
https://stackoverflow.com/questions/35711632/display-dark-16-bit-tiff-in-canvas
|
<p>I'm trying to display a 16-bit tiff image in a html5 canvas, I found this library <a href="https://github.com/seikichi/tiff.js/" rel="nofollow">seikichi/tiff.js</a> and it works well but my images are dark, the pixel values are in the range [0- 300] then the image is quantized badly, the canvas displays a black image. I have tried other alternatives but I have the same problem. Is there any way to implement the quantization? Could suggest another solution or library?</p>
<p>PD: I get the image from a node.js server using ajax</p>
<p>Thanks!! </p>
| 1,529
|
|
implement quantization
|
2-DCT Image compression matlab
|
https://stackoverflow.com/questions/53006940/2-dct-image-compression-matlab
|
<p><strong>Problem:</strong></p>
<p>I tried implementing Discrete Cosine Transformation compression using matlab.
Input image would a jpg image (Lena) having a size 512 X 512.</p>
<p>There are two stages namely compression and decompression. </p>
<p><strong>Compression and Quantization:</strong></p>
<p>The input image is converted to YCbCr component. Then Y component is taken up
for compression. Further DCT will quantized.</p>
<p><strong>Quantization and Decompression:</strong></p>
<p>The quantized image is undergoes dequantization for decompression.</p>
<p><strong>Issues:</strong></p>
<p>Rectangular boxes are spotted in the decompressed version of the image. Is anything wrong with the code?
For your inference, below are the sample input and output images and followed by the matlab code.</p>
<p><strong>Input image:</strong></p>
<p><a href="https://i.sstatic.net/S3L3t.jpg" rel="nofollow noreferrer"><img src="https://i.sstatic.net/S3L3t.jpg" alt="enter image description here"></a></p>
<p><strong>Y Component in YCbCr:</strong></p>
<p><a href="https://i.sstatic.net/AjFDa.jpg" rel="nofollow noreferrer"><img src="https://i.sstatic.net/AjFDa.jpg" alt="enter image description here"></a></p>
<p><strong>Output image:</strong></p>
<p><a href="https://i.sstatic.net/EF6eE.jpg" rel="nofollow noreferrer"><img src="https://i.sstatic.net/EF6eE.jpg" alt="enter image description here"></a></p>
<p><strong>Code:</strong></p>
<pre><code>clc;
clear all;
close all;
I = imread('lena512.jpg');
figure, imshow(I);
% Y = I;
YCbCr = rgb2ycbcr(I);
figure, imshow(YCbCr);
Y = YCbCr(:,:, 1);
figure, imshow(Y);
[h, w] = size(Y);
r = h/8;
c = w/8;
s = 1;
q50 = [16 11 10 16 24 40 51 61;
12 12 14 19 26 58 60 55;
14 13 16 24 40 57 69 56;
14 17 22 29 51 87 80 62;
18 22 37 56 68 109 103 77;
24 35 55 64 81 104 113 92;
49 64 78 87 103 121 120 101;
72 92 95 98 112 100 103 99];
% COMPRESSION
for i=1:r
e = 1;
for j=1:c
block = Y(s:s+7,e:e+7);
cent = double(block) - 128;
for m=1:8
for n=1:8
if m == 1
u = 1/sqrt(8);
else
u = sqrt(2/8);
end
if n == 1
v = 1/sqrt(8);
else
v = sqrt(2/8);
end
comp = 0;
for x=1:8
for y=1:8
comp = comp + cent(x, y)*(cos((((2*(x-1))+1)*(m-1)*pi)/16))*(cos((((2*(y-1))+1)*(n-1)*pi)/16));
end
end
F(m, n) = v*u*comp;
end
end
for x=1:8
for y=1:8
cq(x, y) = round(F(x, y)/q50(x, y));
end
end
Q(s:s+7,e:e+7) = cq;
e = e + 8;
end
s = s + 8;
end
% % % % % % % % % % % % % % %
% % DECOMPRESSION
% % % % % % %
s = 1;
for i=1:r
e = 1;
for j=1:c
cq = Q(s:s+7,e:e+7);
for x=1:8
for y=1:8
DQ(x, y) = q50(x, y)*cq(x, y);
end
end
for m=1:8
for n=1:8
if m == 1
u = 1/sqrt(8);
else
u = sqrt(2/8);
end
if n == 1
v = 1/sqrt(8);
else
v = sqrt(2/8);
end
comp = 0;
for x=1:8
for y=1:8
comp = comp + u*v*DQ(x, y)*(cos((((2*(x-1))+1)*(m-1)*pi)/16))*(cos((((2*(y-1))+1)*(n-1)*pi)/16));
end
end
bf(m, n) = round(comp)+128;
end
end
Org(s:s+7,e:e+7) = bf;
e = e + 8;
end
s = s + 8;
end
imwrite(Y, 'F:\workouts\phd\jpeg\input.jpg');
imwrite(uint8(Org), 'F:\workouts\phd\jpeg\output.jpg');
return;
</code></pre>
<p>Can you suggest me where the error is? It would be helpful.</p>
| 1,530
|
|
implement quantization
|
Error while training pruned and quantized CNN model using TensorFlow Model Optimization
|
https://stackoverflow.com/questions/79052285/error-while-training-pruned-and-quantized-cnn-model-using-tensorflow-model-optim
|
<p>I'm working on a deep learning project where I'm trying to implement a convolutional neural network (CNN) for Human Activity Recognition (HAR) using time-series data. The pipeline involves training a VGG-like teacher model, pruning it for efficiency, applying quantization-aware training, and then distilling the knowledge from the teacher to a smaller student model.</p>
<p>I've structured the pipeline as follows:</p>
<p>Teacher Model: A CNN-based architecture (similar to VGG) that takes windowed time-series data as input for multi-class classification.
Pruning: I use TensorFlow Model Optimization Toolkit (TFMOT) to apply polynomial decay pruning on the teacher model. The pruning works fine initially.
Stripping Pruning Wrappers: After pruning, I strip the pruning wrappers using tfmot.sparsity.keras.strip_pruning().
Quantization-Aware Training (QAT): I apply quantization-aware training to the stripped model using tfmot.quantization.keras.quantize_model().
Knowledge Distillation: Finally, I create a smaller student model and use the pruned and quantized teacher model’s predictions to train the student via knowledge distillation.
Despite the logical flow of the pipeline, I encounter an error during the pruning and quantization-aware training steps. The issue arises during or after the pruning process, where the pruned model cannot be compiled or trained properly.
The specific error:
The error message I get is</p>
<p>`Error while compiling the pruned model: ValueError: The teacher model must be a Keras Model instance.</p>
<p>RuntimeError: Error while applying pruning to the teacher model: prune_low_magnitude can only prune an object of the following types: keras.models.Sequential, keras functional model, keras.layers.Layer, list of keras.layers.Layer. You passed an object of type: Functional.`</p>
<p>This happens when I attempt to wrap the model in prune_low_magnitude() or quantize_model(). I suspect there might be an issue with how I'm handling the TensorFlow Model Optimization Toolkit, but I can't pinpoint it.
<strong>Code Overview:</strong></p>
<h1>Model Definition (VGG-like Teacher Model):</h1>
<pre><code>def create_vgg_like_model(input_shape, num_classes):
inputs = Input(shape=input_shape)
x = Conv2D(64, (3, 3), activation='relu', padding='same')(inputs)
x = Conv2D(64, (3, 3), activation='relu', padding='same')(x)
x = MaxPooling2D((2, 2))(x)
x = Conv2D(128, (3, 3), activation='relu', padding='same')(x)
x = Conv2D(128, (3, 3), activation='relu', padding='same')(x)
x = MaxPooling2D((2, 2))(x)
x = Flatten()(x)
x = Dense(256, activation='relu')(x)
outputs = Dense(num_classes, activation='softmax')(x)
return Model(inputs=inputs, outputs=outputs)
</code></pre>
<p>#Pruning process</p>
<pre><code>pruning_schedule = tfmot.sparsity.keras.PolynomialDecay(
initial_sparsity=0.0, final_sparsity=0.5, begin_step=0, end_step=1000
)
pruned_teacher_model = tfmot.sparsity.keras.prune_low_magnitude(teacher_model, pruning_schedule=pruning_schedule)
pruned_teacher_model.compile(optimizer=Adam(), loss='sparse_categorical_crossentropy', metrics=['accuracy'])
</code></pre>
<h1>Stripping Pruning Wrappers:</h1>
<p>`
stripped_model = tfmot.sparsity.keras.strip_pruning(pruned_teacher_model)</p>
<p>`</p>
<h1>Quantization-Aware Training:</h1>
<pre><code>quantize_model = tfmot.quantization.keras.quantize_model
q_aware_teacher_model = quantize_model(stripped_model)
q_aware_teacher_model.compile(optimizer=Adam(), loss='sparse_categorical_crossentropy', metrics=['accuracy'])
</code></pre>
<h1>Knowledge Distillation Loss:</h1>
<pre><code>def knowledge_distillation_loss(y_true, y_pred, teacher_logits, temperature=3):
soft_labels = tf.nn.softmax(teacher_logits / temperature)
student_logits = tf.nn.log_softmax(y_pred / temperature)
distillation_loss = tf.keras.losses.KLDivergence()(soft_labels, student_logits)
return distillation_loss
</code></pre>
<h1>Data:</h1>
<p>The data is time-series sensor data used for HAR, with windows created for sequences of size 100 and a step size of 50. After windowing, the data is fed into the CNN model.</p>
<p>Window Size: 100
Input Shape: (100, num_features, 1) (where num_features is the number of sensor readings per time step)
Number of Classes: 5 (multi-class classification)
Question:
I’m not sure what’s causing the error regarding the model not being a Keras Model instance. The model works fine until I attempt to apply pruning or quantization. I’d appreciate any guidance on:</p>
<p>What might be going wrong with the pruning and quantization setup?
How to correctly wrap the model for pruning and quantization?
Any debugging tips or potential issues I might be overlooking?
Thanks in advance for any help!</p>
| 1,531
|
|
implement quantization
|
I am trying to implement jpeg compression using FFT2 instead of DCT2 in Matlab and export binary files to be decoded
|
https://stackoverflow.com/questions/75939516/i-am-trying-to-implement-jpeg-compression-using-fft2-instead-of-dct2-in-matlab-a
|
<p>As per the title, I am having more trouble trying to convert to binary file. Below are my steps.</p>
<p><strong>JPEG Compression Steps</strong></p>
<ol>
<li>Convert RGB into 3 channels</li>
<li>For each channel (Y,Cb,Cr)</li>
</ol>
<ul>
<li><p>(2.1) If channel is Cb or Cr</p>
<ul>
<li>Downsample</li>
</ul>
</li>
<li><p>(2.2) Break channel into 8x8 non-overlapping blocks</p>
</li>
<li><p>(2.3) For each block</p>
<ul>
<li>(2.3.1) Apply 2D FFT
<ul>
<li>Output is a 8x8 frequency table</li>
</ul>
</li>
<li>(2.3.2) Quantization
<ul>
<li>Element-wise divide by quantization table</li>
<li>Round to nearest whole number</li>
<li>The quantization table for Y is different from that of Cb and Cr</li>
</ul>
</li>
<li>(2.3.4) ZigZag traversal through the coefficients
<ul>
<li>Maximize the effectiveness of run length encoder</li>
<li>Output is still a 8x8 frequency table but position is changed</li>
</ul>
</li>
<li>(2.3.5) Run Length Encoding
<ul>
<li>Output is a cell with 2 matrix</li>
<li>Count matrix</li>
<li>Symbols matrix</li>
</ul>
</li>
<li>(2.3.6) Huffman encoding
<ul>
<li>Encode count matrix</li>
<li>Encode symbols matrix</li>
</ul>
</li>
</ul>
</li>
</ul>
<ol start="3">
<li>Somehow create a binary file format for export</li>
</ol>
<p><strong>JPEG Decoder Steps</strong></p>
<ul>
<li>Read Binary file</li>
<li>Decode huffman</li>
<li>Reverse run length</li>
<li>Reverse zigzag traversal</li>
<li>Multiply by quantization table</li>
<li>Inverse 2D FFT</li>
<li>Reconstruct 8x8 Block</li>
</ul>
<p>The specifics of the steps depends on the implementation of the Binary file format</p>
<p><strong>Binary file Format</strong></p>
<p>Information it should contain</p>
<ul>
<li>Quantization table (1 for Y and 1 for Cb and Cr)</li>
<li>Huffman table/dictionary</li>
<li>The actual image data</li>
</ul>
<p><strong>Generating Huffman table</strong>
<a href="https://stackoverflow.com/questions/36379725/matlab-jpeg-compression-huffman-encoding">Matlab - JPEG Compression. Huffman Encoding</a></p>
<ol>
<li>Scan through all the blocks to generate a huffman table/dictionary</li>
<li>Encode all the blocks</li>
</ol>
<p>I am new to matlab, I am unfamiliar with how to write binary files. How do I export the Huffman encoding in a binary file? I am working with the builtin matlab huffman functions.</p>
<p>From experimenting with the huffman function, I understand that the output is a cell array of matrices. The first column of the cell array is for symbols, the second column of the cell array is the code. The code is already in binary form but in Matlab it is just an array of integers. My main challenge is trying to write these codes into the binary file. I am not sure to write these code directly as binary values instead of being treated as decimals in matlab.</p>
<p>I would be happy to clarify my question if it is unclear. I would appreciate any help on this :)</p>
| 1,532
|
|
implement quantization
|
Unexpected memory usage when training transformer models with LoRA and quantization
|
https://stackoverflow.com/questions/78895910/unexpected-memory-usage-when-training-transformer-models-with-lora-and-quantizat
|
<p>I am training models using transformers, accelerate, bitsandbytes and PEFT. I recently got a second graphics card (RTX 3090) and am seeing a decent increase in training speed. However when experimenting with Lora and quantization, I found certain combinations weren't reducing memory as I'd expect.</p>
<p>If I understand correctly, accelerate uses DistributedDataParallel (DDP) which copies the model onto both graphics card's memory. So with Lora and BNB turned off, I'd expect to see both cards use 2.6GB. I'm confused as to why they're using over 7GB with accelerate implemented.</p>
<p>I'm using accelerate to utilise 2 graphics cards, and have confirmed both are being utilised 100%.</p>
<p>In all tests I'm using DistilBERT (66 million params), the same data, batch size of 16. Memory clears to 0 after each test. I'm only changing the model loading:</p>
<pre><code># 4 bit config
bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type= "nf4",
bnb_4bit_compute_dtype= torch.bfloat16,
bnb_4bit_use_double_quant= False,
)
</code></pre>
<pre><code># 8bit config
bnb_config = BitsAndBytesConfig(
load_in_8bit=True,
llm_int8_threshold=6.0,
llm_int8_skip_modules=None,
)
</code></pre>
<pre><code># Lora
peft_config = LoraConfig(
task_type="SEQ_CLS", # sequence classification
lora_alpha=16,
lora_dropout=0.1,
r=8,
bias="none",
target_modules=["query", "key", "value", "query_global", "key_global", "value_global"]
)
model = get_peft_model(model, peft_config)
model = prepare_model_for_kbit_training(model)
</code></pre>
<p><a href="https://i.sstatic.net/b38SxXUr.png" rel="nofollow noreferrer"><img src="https://i.sstatic.net/b38SxXUr.png" alt="Table of memory reduction techniques" /></a></p>
| 1,533
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.