Codefuse-ChatBot: Development by Private Knowledge Augmentation #682
Comments
irthomasthomas
added
AI-Chatbots
Related issues#305: Home - LibreChat### DetailsSimilarity score: 0.89 - [ ] [Home - LibreChat](https://docs.librechat.ai/index.html)Table of contents LibreChat 🪶 Features 🖥️ UI matching ChatGPT, including Dark mode, Streaming, and 11-2023 updates LibreChat brings together the future of assistant AIs with the revolutionary technology of OpenAI's ChatGPT. Celebrating the original styling, LibreChat gives you the ability to integrate multiple AI models. It also integrates and enhances original client features such as conversation and message search, prompt templates and plugins. With LibreChat, you no longer need to opt for ChatGPT Plus and can instead use free or pay-per-call APIs. We welcome contributions, cloning, and forking to enhance the capabilities of this advanced chatbot platform. Suggested labels"ai-platform"#656: ChatCraft - open-source web companion for coding with LLMs.### DetailsSimilarity score: 0.88 - [ ] [New Chat - ChatCraft](https://chatcraft.org/c/zIpIpIKuJ8E3S8jlMsJTO)New Chat - ChatCraftDESCRIPTION: We think ChatCraft is the best platform for learning, experimenting, and getting creative with code. Here's a few of the reasons why we think you'll agree:
Learn more about ChatCraft on GitHub Quick Start Instructions
Suggested labels#96: ChatDev: Create Customized Software using Natural Language through LLM-powered Multi-Agent Collaboration### DetailsSimilarity score: 0.88 - [ ] https://arxiv.org/pdf/2307.07924.pdf#418: openchat/openchat-3.5-1210 · Hugging Face### DetailsSimilarity score: 0.88 - [ ] [openchat/openchat-3.5-1210 · Hugging Face](https://huggingface.co/openchat/openchat-3.5-1210#conversation-templates)Using the OpenChat ModelWe highly recommend installing the OpenChat package and using the OpenChat OpenAI-compatible API server for an optimal experience. The server is optimized for high-throughput deployment using vLLM and can run on a consumer GPU with 24GB RAM.
Online DeploymentIf you want to deploy the server as an online service, use the following options:
For security purposes, we recommend using an HTTPS gateway in front of the server. Mathematical Reasoning ModeThe OpenChat model also supports mathematical reasoning mode. To use this mode, include Conversation TemplatesWe provide several pre-built conversation templates to help you get started.
Suggested labels{ "label": "chat-templates", "description": "Pre-defined conversation structures for specific modes of interaction." }#383: deepseek-ai/deepseek-coder-5.7bmqa-base · Hugging Face### DetailsSimilarity score: 0.87 - [ ] [deepseek-ai/deepseek-coder-5.7bmqa-base · Hugging Face](https://huggingface.co/deepseek-ai/deepseek-coder-5.7bmqa-base)Deepseek Coder IntroductionDeepseek Coder is a series of code language models, each trained from scratch on 2T tokens with a composition of 87% code and 13% natural language in both English and Chinese. We provide various sizes of the code model, ranging from 1B to 33B versions. Each model is pre-trained on a project-level code corpus with a window size of 16K and an extra fill-in-the-blank task, supporting project-level code completion and infilling. Deepseek Coder achieves state-of-the-art performance among open-source code models on multiple programming languages and various benchmarks. Key Features
Model Summary
How to UseThis section provides examples of how to use the Deepseek Coder model for code completion, code insertion, and repository-level code completion tasks. Code Completionfrom transformers import AutoTokenizer, AutoModelForCausalLM
import torch
tokenizer = AutoTokenizer.from_pretrained("deepseek-ai/deepseek-coder-5.7bmqa-base", trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained("deepseek-ai/deepseek-coder-5.7bmqa-base", trust_remote_code=True).cuda()
input_text = "#write a quick sort algorithm"
inputs = tokenizer(input_text, return_tensors="pt").to(model.device)
outputs = model.generate(**inputs, max_length=128)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))Code Insertionfrom transformers import AutoTokenizer, AutoModelForCausalLM
import torch
tokenizer = AutoTokenizer.from_pretrained("deepseek-ai/deepseek-coder-5.7bmqa-base", trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained("deepseek-ai/deepseek-coder-5.7bmqa-base", trust_remote_code=True).cuda()
input_text = """<|begin|>def quick_sort(arr):
if len(arr) <= 1:
return arr
pivot = arr[0]
left = []
right = []
<|hole|>
if arr[i] < pivot:
left.append(arr[i])
else:
right.append(arr[i])
return quick_sort(left) + [pivot] + quick_sort(right)<|end|>"""
inputs = tokenizer(input_text, return_tensors="pt").to(model.device)
outputs = model.generate(**inputs, max_length=128)
print(tokenizer.decode(outputs[0], skip_special_tokens=True)[len(input_text):])Repository Level Code Completionfrom transformers import AutoTokenizer, AutoModelForCausalLM
tokenizer = AutoTokenizer.from_pretrained("deepseek-ai/deepseek-coder-5.7bmqa-base", trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained("deepseek-ai/deepseek-coder-5.7bmqa-base", trust_remote_code=True).cuda()
input_text = """#utils.py
import torch
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score
def load_data():
iris = datasets.load_iris()
X = iris.data
y = iris.target
# Standardize the data
scaler = StandardScaler()
X = scaler.fit_transform(X)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
# Convert numpy data to PyTorch tensors
X_train = torch.tensor(X_train, dtype=torch.float32)
X_test = torch.tensor(X_test, dtype=torch.float32)
y_train = torch.tensor(y_train, dtype=torch.int64)
y_test = torch.tensor(y_test, dtype=torch.int64)
return X_train, X_test, y_train, y_test
def evaluate_predictions(y_test, y_pred):
return accuracy_score(y_test, y_pred)
#model.py
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
class IrisClassifier(nn.Module):
def __init__(self):
super(IrisClassifier, self).__init__()
self.fc = nn.Sequential(
nn.Linear(4, 16),
nn.ReLU(),
nn.Linear(16, 3)
)
def forward(self, x):
return self.fc(x)
def train_model(self, X_train, y_train, epochs, lr, batch_size):
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(self.parameters(), lr=lr)
# Create DataLoader for batches
dataset = TensorDataset(X_train, y_train)
dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)
for epoch in range(epochs):
for batch_X, batch_y in dataloader:
optimizer.zero_grad()
outputs = self(batch_X)
loss = criterion(outputs, batch_y)
loss.backward()
optimizer.step()
def predict(self, X_test):
with torch.no_grad():
outputs = self(X_test)
_, predicted = outputs.max(1)
return predicted.numpy()
#main.py
from utils import load_data, evaluate_predictions
from model import IrisClassifier as Classifier
def main():
# Model training and evaluation
"""
inputs = tokenizer(input_text, return_tensors="pt").to(model.device)
outputs = model.generate(**inputs, max_new_tokens=140)
print(tokenizer.decode(outputs[0]))LicenseThis code repository is licensed under the MIT License. The use of Deepseek Coder models is subject to the Model License. DeepSeek Coder supports commercial use. See the LICENSE-MODEL for more details. ContactIf you have any questions, please raise an issue or contact us at agi_code@deepseek.com. Suggested labels{ "key": "llm-experiments", "value": "Experiments and results related to Large Language Models" } { "key": "AI-Chatbots", "value": "Topics related to advanced chatbot platforms integrating multiple AI models" }#488: Can Ai Code Results - a Hugging Face Space by mike-ravkine### DetailsSimilarity score: 0.87 - [ ] [Can Ai Code Results - a Hugging Face Space by mike-ravkine](https://huggingface.co/spaces/mike-ravkine/can-ai-code-results)Can Ai Code Results - a Hugging Face Space by mike-ravkineDescriptionhallucinations[Can Ai Code Results](https://huggingface.co/spaces/mike-ravkine/can-ai-code-results) This is a Hugging Face Space showcasing the results of an experiment to determine if AI can generate code. The Space uses a model fine-tuned on a dataset of code to predict what code should come next given a prompt. You can try out the model in the Interactive Mode or check out the code in the Static Mode. Interactive ModeIn the Interactive Mode, you can enter a prompt and the model will generate some code for you. Here are some example prompts:
Static ModeIn the Static Mode, you can see examples of code generated by the model. You can also see the true code and compare it to the AI's code. DatasetThe dataset used to fine-tune the model is called The Human Evaluated Dataset of Code Completions. It contains 5,000 examples of code from 5 programming languages:
Each example in the dataset has the following structure:
ModelThe model used in this Space is a Transformer-based model. It was fine-tuned on the Human Evaluated Dataset of Code Completions for 10 epochs. ConclusionAfter running this experiment, it seems that AI can generate code that is fairly similar to human-written code. However, there is still room for improvement as the AI's code is not always perfect. Nevertheless, this Space demonstrates the potential of using AI to assist with coding tasks. It could be useful for generating code snippets or for helping beginners learn programming. Suggested labels{ "label-name": "ai-technology", "description": "Content related to AI technology.", "confidence": 94.84 } |
irthomasthomas
changed the title
codefuse-chatbot/README_en.md at main · codefuse-ai/codefuse-chatbot
DESCRIPTION:
中文 ｜ English
Codefuse-ChatBot: Development by Private Knowledge Augmentation
This project is an open-source AI intelligent assistant, specifically designed for the entire lifecycle of software development, covering design, coding, testing, deployment, and operations. Through knowledge retrieval, tool utilization, and sandbox execution, Codefuse-ChatBot can not only answer professional questions you encounter during the development process but also coordinate multiple independent, dispersed platforms through a conversational interface.
🔔 Updates
📜 Contents
🤝 Introduction
💡 The aim of this project is to construct an AI intelligent assistant for the entire lifecycle of software development, covering design, coding, testing, deployment, and operations, through Retrieval Augmented Generation (RAG), Tool Learning, and sandbox environments. It transitions gradually from the traditional development and operations mode of querying information from various sources and operating on standalone, disparate platforms to an intelligent development and operations mode based on large-model Q&A, changing people's development and operations habits.
🌍 Relying on open-source LLM and Embedding models, this project can achieve offline private deployments based on open-source models. Additionally, this project also supports the use of the OpenAI API. Access Demo
👥 The core development team has been long-term focused on research in the AIOps + NLP domain. We initiated the CodefuseGPT project, hoping that everyone could contribute high-quality development and operations documents widely, jointly perfecting this solution to achieve the goal of "Making Development Seamless for Everyone."
URL: codefuse-chatbot
Suggested labels
{'label-name': 'intelligent-assistants', 'label-description': 'Technology that assists users in various tasks using artificial intelligence.', 'gh-repo': 'codefuse-ai/codefuse-chatbot', 'confidence': 50.58}
The text was updated successfully, but these errors were encountered: