Simplismart’s software-level optimisations enabled Llama 3.1 8B to achieve a throughput of over 343 tokens per second.

This Bengaluru Startup Made the Fastest Inference Engine, Beating Together AI and Fireworks AI

Zuckerberg said Meta's Llama 4 models were training on an H100 cluster "bigger than anything that I've seen reported for what others are doing."

Mark Zuckerberg Flexes Meta's Nvidia Chip Cluster - Business Insider

Nvidia recently released an open-source AI model built on Meta’s Llama-3 called “Nemotron” that surpasses OpenAI’s GPT-4o on many popular benchmarks.

Nvidia’s new open-source AI model beats GPT-4o on benchmarks

Expanding the open-source Meta Llama collection of models, the Llama 3.2 collection includes vision language models (VLMs), small language models (SLMs), and an updated Llama Guard model with support…

Deploying Accelerated Llama 3.2 from the Edge to the Cloud | NVIDIA Technical Blog

Gemma chatbots can run locally, and they reportedly outperform Meta&#x27;s <strong>Llama</strong> 2.

Google goes “open AI” with Gemma, a free, open-weights chatbot family | Ars Technica

Google AI—a division of the search giant—unveiled Gemma today, a new family of open-source language models derived from its recently released Gemini suite of AI tools. With Gemma, Google is directly challenging the leading position of LLMs based on Meta’s <strong>LLaMa</strong> and Mistral.

Google Has a New Open-Source AI Model—Can It Compete With Meta's Llama-2? - Decrypt

Google has unveiled Gemma, a new family of open models, leveraging the research and technology behind the existing Gemini models.

Google Challenges Meta’s Llama 2 with Lightweight Open Source LLM, Gemma

Llama

llama

Fine-Tuning LLaMA for Multi-Stage Text Retrieval: Conclusion, Acknowledgements and References

Authors:
(1) Xueguang Ma, David R. Cheriton School of Computer Science, University of Waterloo;
(2) Liang Wang, Microsoft Research;
(3) Nan Yang, Microsoft Research;
(4) Furu Wei, Microsoft Research;
(5) Jimmy Lin, David R. Cheriton School of Computer Science, University of Waterloo. Table of Links Abstract and Introduction Method Experiments Ablation Study and Analysis Related Work Conclusion, Acknowledgements and References 5 Related Work 5.1 Large Language Models Pre-trained language models based on the Transformer architecture (Vaswani et al., 2017) have demonstrated impressive capabilities when finetuned for various downstream tasks since the advent of BERT (Devlin et al., 2019). Depending on their architecture, pre-trained Transformers can be classified into three categories: encoder-only models (Devlin et al., 2019; Liu et al., 2019; Conneau et al., 2020), encoder–decoder models (Raffel et al., 2020; Lewis et al., 2020a), and decoder-only models (Radford et al., 2018). Decoder-only models like GPT/GPT-2 have been lauded for their simplicity in terms of model architecture and pre-training procedures (Radford et al., 2018, 2019). Recent research has shown that scaling up LLMs by pre-training larger decoder-only models using larger and higher quality corpora can significantly enhance model capabilities for general-purpose NLP tasks such as question answering and code generation (Wei et al., 2022; Chen et al., 2021). This is achieved by fine-tuning the pre-trained LLMs with instruction-following data using reinforcement learning with human feedback. InstructGPT (Ouyang et al., 2022) and GPT-4 (OpenAI, 2023) are two popular representatives in this class of models. Among the many implementations of open-source large language models, LLaMA (Touvron et al., 2023a,b) is among the most recent and among the top-performing on a variety of tasks. 5.2 Multi-Stage Text Retrieval While multi-stage retrieval pipelines date back well over a decade (Matveeva et al., 2006; Cambazoglu et al., 2010; Wang et al., 2011), they have benefited immensely from pre-trained language models such as BERT in recent years, starting with the monoBERT reranking model (Nogueira and Cho, 2019). Nogueira et al. (2019) proposed a multi-stage retrieval pipeline that employs a BM25 retriever followed by two BERT-based reranking stages. This design demonstrates the effectiveness of pre-trained language models in reranking tasks. RankLLaMA follows the same basic design as monoBERT. The dense passage retriever (DPR) further proposed to fine-tune BERT to replace the BM25 retriever with a dense retrieval model in a bi-encoder design (Karpukhin et al., 2020). DPR encodes text into low-dimensional dense vector representations and treats retrieval as a nearest-neighbor search task. RepLLaMA follows the same bi-encoder design. Several solutions have been introduced to enhance the effectiveness of retrievers and rerankers in a multi-stage pipeline. On the retriever side, works such as ANCE (Xiong et al., 2021), RocketQA (Qu et al., 2021), CoCondenser (Gao and Callan, 2022b), RetroMAE (Xiao et al., 2022), and SimLM (Wang et al., 2023), have shown that augmenting the training data with hard negative mining or continuous retrieval-oriented pre-training can improve the effectiveness of dense retrievers. On the reranker side, monoT5 (Nogueira et al., 2020) and monoELECTRA (Pradeep et al., 2022) demonstrated that initializing the reranker with a custom pre-trained model can enhance effectiveness. Gao et al., 2021 proposed using a contrastive loss for reranker training to replace the default pairwise loss. Zhuang et al. (2023) studied the use of T5 as a reranker, analyzing the influence of different model architectures and loss functions. However, directly fine-tuning modern billion-parameter-scale large language models for multi-stage retrieval has not been explored to date. Recently, LLMs have demonstrated impressive effectiveness when prompted to perform few-shot or zero-shot text generation. As mentioned in the introduction, researchers have cast reranking as text generation. These models can be leveraged to directly generate a reordered list of candidates, e.g., LRL (Ma et al., 2023), RankGPT (Sun et al., 2023), RankVicuna (Pradeep et al., 2023). Alternatively, they can compare passages in a pairwise manner, e.g., PRP (Qin et al., 2023). Although promptbased methods have shown good zero-shot effectiveness, they require multiple decoding passes, thus making them slow and non-parallelizable. Furthermore, reranking with prompts makes it difficult to exploit available human judgments such as MS MARCO (Bajaj et al., 2016) to further improve effectiveness. Finally, these approaches do not allow for joint reranker–retriever optimization. In contrast, we address all these issues. Our work is most similar to GPT-XXL (Ni et al., 2022) and SGPT (Muennighoff, 2022), which also used billion-parameter-scale models as backbones of dense retrievers, achieving better zero-shot effectiveness than smaller models. However, LLaMA has demonstrated even better effectiveness on natural language generation tasks, suggesting that it might serve as a better backbone and warranting further exploration. The cpt-text model (Neelakantan et al., 2022), initialized with the 175-billionparameter GPT-3 model, also shows strong zeroshot effectiveness. However, cpt-text is not an opensource model. Additionally, none of the models referenced above are fully optimized for a multistage retrieval pipeline. Our RepLLaMA and RankLLaMA models are fully open-source and optimized for multi-stage retrieval, achieving state-ofthe-art effectiveness on both retrieval and reranking, for both in-domain and out-of-domain evaluations. This paper is available on arxiv under CC 4.0 license. Authors: (1) Xueguang Ma, David R. Cheriton School of Computer Science, University of Waterloo; (2) Liang Wang, Microsoft Research; (3) Nan Yang, Microsoft Research; (4) Furu Wei, Microsoft Research; (5) Jimmy Lin, David R. Cheriton School of Computer Science, University of Waterloo. Authors: Authors: (1) Xueguang Ma, David R. Cheriton School of Computer Science, University of Waterloo; (2) Liang Wang, Microsoft Research; (3) Nan Yang, Microsoft Research; (4) Furu Wei, Microsoft Research; (5) Jimmy Lin, David R. Cheriton School of Computer Science, University of Waterloo. Table of Links Abstract and Introduction Abstract and Introduction Method Method Experiments Experiments Ablation Study and Analysis Ablation Study and Analysis Related Work Related Work Conclusion, Acknowledgements and References Conclusion, Acknowledgements and References 5 Related Work 5.1 Large Language Models Pre-trained language models based on the Transformer architecture (Vaswani et al., 2017) have demonstrated impressive capabilities when finetuned for various downstream tasks since the advent of BERT (Devlin et al., 2019). Depending on their architecture, pre-trained Transformers can be classified into three categories: encoder-only models (Devlin et al., 2019; Liu et al., 2019; Conneau et al., 2020), encoder–decoder models (Raffel et al., 2020; Lewis et al., 2020a), and decoder-only models (Radford et al., 2018). Decoder-only models like GPT/GPT-2 have been lauded for their simplicity in terms of model architecture and pre-training procedures (Radford et al., 2018, 2019). Recent research has shown that scaling up LLMs by pre-training larger decoder-only models using larger and higher quality corpora can significantly enhance model capabilities for general-purpose NLP tasks such as question answering and code generation (Wei et al., 2022; Chen et al., 2021). This is achieved by fine-tuning the pre-trained LLMs with instruction-following data using reinforcement learning with human feedback. InstructGPT (Ouyang et al., 2022) and GPT-4 (OpenAI, 2023) are two popular representatives in this class of models. Among the many implementations of open-source large language models, LLaMA (Touvron et al., 2023a,b) is among the most recent and among the top-performing on a variety of tasks. 5.2 Multi-Stage Text Retrieval While multi-stage retrieval pipelines date back well over a decade (Matveeva et al., 2006; Cambazoglu et al., 2010; Wang et al., 2011), they have benefited immensely from pre-trained language models such as BERT in recent years, starting with the monoBERT reranking model (Nogueira and Cho, 2019). Nogueira et al. (2019) proposed a multi-stage retrieval pipeline that employs a BM25 retriever followed by two BERT-based reranking stages. This design demonstrates the effectiveness of pre-trained language models in reranking tasks. RankLLaMA follows the same basic design as monoBERT. The dense passage retriever (DPR) further proposed to fine-tune BERT to replace the BM25 retriever with a dense retrieval model in a bi-encoder design (Karpukhin et al., 2020). DPR encodes text into low-dimensional dense vector representations and treats retrieval as a nearest-neighbor search task. RepLLaMA follows the same bi-encoder design. Several solutions have been introduced to enhance the effectiveness of retrievers and rerankers in a multi-stage pipeline. On the retriever side, works such as ANCE (Xiong et al., 2021), RocketQA (Qu et al., 2021), CoCondenser (Gao and Callan, 2022b), RetroMAE (Xiao et al., 2022), and SimLM (Wang et al., 2023), have shown that augmenting the training data with hard negative mining or continuous retrieval-oriented pre-training can improve the effectiveness of dense retrievers. On the reranker side, monoT5 (Nogueira et al., 2020) and monoELECTRA (Pradeep et al., 2022) demonstrated that initializing the reranker with a custom pre-trained model can enhance effectiveness. Gao et al., 2021 proposed using a contrastive loss for reranker training to replace the default pairwise loss. Zhuang et al. (2023) studied the use of T5 as a reranker, analyzing the influence of different model architectures and loss functions. However, directly fine-tuning modern billion-parameter-scale large language models for multi-stage retrieval has not been explored to date. Recently, LLMs have demonstrated impressive effectiveness when prompted to perform few-shot or zero-shot text generation. As mentioned in the introduction, researchers have cast reranking as text generation. These models can be leveraged to directly generate a reordered list of candidates, e.g., LRL (Ma et al., 2023), RankGPT (Sun et al., 2023), RankVicuna (Pradeep et al., 2023). Alternatively, they can compare passages in a pairwise manner, e.g., PRP (Qin et al., 2023). Although promptbased methods have shown good zero-shot effectiveness, they require multiple decoding passes, thus making them slow and non-parallelizable. Furthermore, reranking with prompts makes it difficult to exploit available human judgments such as MS MARCO (Bajaj et al., 2016) to further improve effectiveness. Finally, these approaches do not allow for joint reranker–retriever optimization. In contrast, we address all these issues. Our work is most similar to GPT-XXL (Ni et al., 2022) and SGPT (Muennighoff, 2022), which also used billion-parameter-scale models as backbones of dense retrievers, achieving better zero-shot effectiveness than smaller models. However, LLaMA has demonstrated even better effectiveness on natural language generation tasks, suggesting that it might serve as a better backbone and warranting further exploration. The cpt-text model (Neelakantan et al., 2022), initialized with the 175-billionparameter GPT-3 model, also shows strong zeroshot effectiveness. However, cpt-text is not an opensource model. Additionally, none of the models referenced above are fully optimized for a multistage retrieval pipeline. Our RepLLaMA and RankLLaMA models are fully open-source and optimized for multi-stage retrieval, achieving state-ofthe-art effectiveness on both retrieval and reranking, for both in-domain and out-of-domain evaluations. This paper is available on arxiv under CC 4.0 license. This paper is available on arxiv under CC 4.0 license. available on arxiv

Related Work on Fine-Tuning LLaMA for Multi-Stage Text Retrieval

Authors:
(1) Xueguang Ma, David R. Cheriton School of Computer Science, University of Waterloo;
(2) Liang Wang, Microsoft Research;
(3) Nan Yang, Microsoft Research;
(4) Furu Wei, Microsoft Research;
(5) Jimmy Lin, David R. Cheriton School of Computer Science, University of Waterloo. Table of Links Abstract and Introduction Method Experiments Ablation Study and Analysis Related Work Conclusion, Acknowledgements and References 4 Ablation Study and Analysis 4.1 Full Fine-Tuning vs. LoRA When fine-tuning large language models, a key decision is whether to conduct full fine-tuning, which updates all parameters in the model, or to use a parameter-efficient method such as LoRA. Table 4 compares the effectiveness of RepLLaMA when trained with full fine-tuning and LoRA for the passage retrieval task. Both models are trained on the training set for one epoch. We see that full fine-tuning achieves an MRR@10 score that is approximately 6 points higher than with LoRA on the training set. However, on the development set, full fine-tuning only improves effectiveness by 0.4 points compared to LoRA. Interestingly, on the TREC DL19/DL20 datasets, which are derived from independent human judgments, LoRA demonstrates better effectiveness. This suggests that full fine-tuning may be prone to overfitting on the training set distribution, while LoRA, with significantly fewer parameters, can generalizable better. For this reason, all the models presented in our main experiments (Section 3) use LoRA instead of full fine-tuning. 4.2 Input Sequence Length As discussed in Section 3.2, RankLLaMA has the advantage of accommodating longer inputs compared to previous models like BERT since its LLaMA backbone was pre-trained with a longer context window. We investigate the effects of varying the maximum training input length and inference input length on model effectiveness for the document reranking task. Results presented in Figure 2 show a clear trend: the effectiveness of RankLLaMA improves as the maximum training length increases from 512 to 2048, with the MRR@100 score improving from 48.5 to 50.3. When the reranking input length is further increased to 4096, the MRR@100 score rises to 50.6. This demonstrates the model’s ability to exploit longer sequences for improved effectiveness. However, it is important to note that the gains plateau beyond a certain length, suggesting a point of diminishing returns. The MRR@100 for the model trained with a length of 4096 is only 0.3 points higher than the model trained with a length of 2048, when evaluated on input lengths that match their training lengths. Moreover, the model trained with a length of 4096 takes about 8 days to train using 16 × V100 GPUs, while the model with a length of 2048 takes about 4 days. The same relative latency costs apply to inference as well. Therefore, while RankLLaMA can handle much longer input documents, it is crucial to balance this capability with the practical considerations of computational efficiency. This paper is available on arxiv under CC 4.0 license. Authors: (1) Xueguang Ma, David R. Cheriton School of Computer Science, University of Waterloo; (2) Liang Wang, Microsoft Research; (3) Nan Yang, Microsoft Research; (4) Furu Wei, Microsoft Research; (5) Jimmy Lin, David R. Cheriton School of Computer Science, University of Waterloo. Authors: Authors: (1) Xueguang Ma, David R. Cheriton School of Computer Science, University of Waterloo; (2) Liang Wang, Microsoft Research; (3) Nan Yang, Microsoft Research; (4) Furu Wei, Microsoft Research; (5) Jimmy Lin, David R. Cheriton School of Computer Science, University of Waterloo. Table of Links Abstract and Introduction Abstract and Introduction Method Method Experiments Experiments Ablation Study and Analysis Ablation Study and Analysis Related Work Related Work Conclusion, Acknowledgements and References Conclusion, Acknowledgements and References 4 Ablation Study and Analysis 4.1 Full Fine-Tuning vs. LoRA When fine-tuning large language models, a key decision is whether to conduct full fine-tuning, which updates all parameters in the model, or to use a parameter-efficient method such as LoRA. Table 4 compares the effectiveness of RepLLaMA when trained with full fine-tuning and LoRA for the passage retrieval task. Both models are trained on the training set for one epoch. We see that full fine-tuning achieves an MRR@10 score that is approximately 6 points higher than with LoRA on the training set. However, on the development set, full fine-tuning only improves effectiveness by 0.4 points compared to LoRA. Interestingly, on the TREC DL19/DL20 datasets, which are derived from independent human judgments, LoRA demonstrates better effectiveness. This suggests that full fine-tuning may be prone to overfitting on the training set distribution, while LoRA, with significantly fewer parameters, can generalizable better. For this reason, all the models presented in our main experiments (Section 3) use LoRA instead of full fine-tuning. 4.2 Input Sequence Length As discussed in Section 3.2, RankLLaMA has the advantage of accommodating longer inputs compared to previous models like BERT since its LLaMA backbone was pre-trained with a longer context window. We investigate the effects of varying the maximum training input length and inference input length on model effectiveness for the document reranking task. Results presented in Figure 2 show a clear trend: the effectiveness of RankLLaMA improves as the maximum training length increases from 512 to 2048, with the MRR@100 score improving from 48.5 to 50.3. When the reranking input length is further increased to 4096, the MRR@100 score rises to 50.6. This demonstrates the model’s ability to exploit longer sequences for improved effectiveness. However, it is important to note that the gains plateau beyond a certain length, suggesting a point of diminishing returns. The MRR@100 for the model trained with a length of 4096 is only 0.3 points higher than the model trained with a length of 2048, when evaluated on input lengths that match their training lengths. Moreover, the model trained with a length of 4096 takes about 8 days to train using 16 × V100 GPUs, while the model with a length of 2048 takes about 4 days. The same relative latency costs apply to inference as well. Therefore, while RankLLaMA can handle much longer input documents, it is crucial to balance this capability with the practical considerations of computational efficiency. This paper is available on arxiv under CC 4.0 license. This paper is available on arxiv under CC 4.0 license. available on arxiv

Fine-Tuning LLaMA for Multi-Stage Text Retrieval: Ablation Study and Analysis

Fine-Tuning LLaMA for Multi-Stage Text Retrieval: Experiments

Authors:
(1) Xueguang Ma, David R. Cheriton School of Computer Science, University of Waterloo;
(2) Liang Wang, Microsoft Research;
(3) Nan Yang, Microsoft Research;
(4) Furu Wei, Microsoft Research;
(5) Jimmy Lin, David R. Cheriton School of Computer Science, University of Waterloo. Table of Links Abstract and Introduction Method Experiments Ablation Study and Analysis Related Work Conclusion, Acknowledgements and References 2 Method 2.1 Preliminaries Task Definition Given a query Q and a corpus C = {D1, D2, ..., Dn} consisting of n documents, the goal of text retrieval is to find the k documents that are most relevant to the query Q, with k ≪ n. In a multi-stage retrieval pipeline composed by a retriever and a reranker, the retriever’s task is to efficiently generate the top-k candidates that are relevant to the query based on the similarity metric Sim(Q, D) ∈ R. The reranker’s task is to reorder these k candidate documents further to improve the relevance order using a more effective, but typically more computationally expensive reranking model. Note that “document” in this context can refer to an arbitrary information snippet, including sentences, passages, or full documents. While a multi-stage pipeline can contain multiple rerankers, in this paper we focus on a single reranker. Modern retrievers typically follow a bi-encoder architecture that encodes text into vector representations, with Sim(Q, D) computed as the dot product of the vector representations of the query Q and a document D (Karpukhin et al., 2020). In contrast, a (pointwise) reranker typically takes both the query and a candidate document as input to directly generate a relevance score. These scores are then used to reorder the candidates (Nogueira et al., 2019; Gao et al., 2021). LLaMA LLaMA (Touvron et al., 2023a) is an auto-regressive, decoder-only large language model based on the Transformer architecture. The model is characterized by its billions of parameters, pre-trained on a vast amount of web data. Being uni-directional means that the model’s attention mechanism only considers the preceding elements in the input sequence when making predictions. Specifically, given an input sequence x = [t1, t2, ..., tn−1], the model computes the probability of the next token tn based solely on the preceding tokens. The prediction process can be mathematically represented as P(tn|t1, ..., tn−1), where P denotes the probability and tn represents the next element in the sequence. 2.2 Retriever Our retriever model, called RepLLaMA, follows the bi-encoder dense retriever architecture proposed in DPR (Karpukhin et al., 2020), but with the backbone model initialized with LLaMA. Previous work on dense retriever models often uses a bi-directional encoder-only model like BERT, taking the representation of the prepended [CLS] token as the dense representation of the text input. However, as LLaMA is uni-directional, we append an end-of-sequence token to the input query or document to form the input sequence to LLaMA. Thus, the vector embedding of a query or a document is computed as: where Decoder(·) represents the LLaMA model, which returns the last layer token representation for each input token. We take the representation of the end-of-sequence token as the representation of the input sequence t1 . . . tk, which can be either a query Q or a document D. Relevance of D to Q is computed in terms of the dot product of their corresponding dense representation VQ and VD as Sim(Q, D) =< VQ, VD >. The model is then optimized end-to-end according to InfoNCE loss: Here, D+ represents a document that is relevant to the query Q (based on human labels), while {DN } denotes a set of documents that is not relevant to the query. The set of negative documents includes both hard negatives, which are sampled from the top-ranking results of an existing retrieval system, and in-batch negatives, which are derived from the positive documents and hard negative documents associated with other queries in the same training batch. In practice, dense retrieval training tends to benefit from a larger set of hard negatives and in-batch negatives. During the inference phase, the query is typically encoded in real-time and the top-k similar documents are searched within the pre-encoded corpus using an efficient approximate nearest neighbour search library such as HNSW (Malkov and Yashunin, 2020). However, in this study, we opt to perform exact nearest neighbour search using flat indexes to evaluate model effectiveness. 2.3 Reranker Our reranker model, referred to as RankLLaMA, is trained as a pointwise reranker. This approach involves passing a query and a candidate document together as model input, with the model generating a score that indicates the relevance of the document to the query (Nogueira et al., 2019). In more detail, RankLLaMA reranks a query– document pair as follows: where Linear(·) is a linear projection layer that projects the last layer representation of the end-ofsequence token to a scalar. Similar to the retriever, the model is optimized by contrastive loss. However, in this case, the negative documents do not involve in-batch negatives. To train a reranker that is optimized to rerank candidates from a specific retriever in a multi-stage pipeline, hard negatives should be sampled from the top-ranking results from that retriever. Specifically, in our case, the hard negative training data for RankLLaMA are selected from the top-ranking results of RepLLaMA. During the inference stage, the top candidate documents retrieved by RepLLaMA are reordered. This reordering is based on the relevance score that RankLLaMA assigns to each query–document pair, with the documents arranged in descending order of relevance. This paper is available on arxiv under CC 4.0 license. Authors: (1) Xueguang Ma, David R. Cheriton School of Computer Science, University of Waterloo; (2) Liang Wang, Microsoft Research; (3) Nan Yang, Microsoft Research; (4) Furu Wei, Microsoft Research; (5) Jimmy Lin, David R. Cheriton School of Computer Science, University of Waterloo. Authors: Authors: (1) Xueguang Ma, David R. Cheriton School of Computer Science, University of Waterloo; (2) Liang Wang, Microsoft Research; (3) Nan Yang, Microsoft Research; (4) Furu Wei, Microsoft Research; (5) Jimmy Lin, David R. Cheriton School of Computer Science, University of Waterloo. Table of Links Abstract and Introduction Abstract and Introduction Method Method Experiments Experiments Ablation Study and Analysis Ablation Study and Analysis Related Work Related Work Conclusion, Acknowledgements and References Conclusion, Acknowledgements and References 2 Method 2.1 Preliminaries Task Definition Given a query Q and a corpus C = {D1, D2, ..., Dn} consisting of n documents, the goal of text retrieval is to find the k documents that are most relevant to the query Q, with k ≪ n. In a multi-stage retrieval pipeline composed by a retriever and a reranker, the retriever’s task is to efficiently generate the top-k candidates that are relevant to the query based on the similarity metric Sim(Q, D) ∈ R. The reranker’s task is to reorder these k candidate documents further to improve the relevance order using a more effective, but typically more computationally expensive reranking model. Note that “document” in this context can refer to an arbitrary information snippet, including sentences, passages, or full documents. While a multi-stage pipeline can contain multiple rerankers, in this paper we focus on a single reranker. Task Definition Modern retrievers typically follow a bi-encoder architecture that encodes text into vector representations, with Sim(Q, D) computed as the dot product of the vector representations of the query Q and a document D (Karpukhin et al., 2020). In contrast, a (pointwise) reranker typically takes both the query and a candidate document as input to directly generate a relevance score. These scores are then used to reorder the candidates (Nogueira et al., 2019; Gao et al., 2021). LLaMA LLaMA (Touvron et al., 2023a) is an auto-regressive, decoder-only large language model based on the Transformer architecture. The model is characterized by its billions of parameters, pre-trained on a vast amount of web data. Being uni-directional means that the model’s attention mechanism only considers the preceding elements in the input sequence when making predictions. Specifically, given an input sequence x = [t1, t2, ..., tn−1], the model computes the probability of the next token tn based solely on the preceding tokens. The prediction process can be mathematically represented as P(tn|t1, ..., tn−1), where P denotes the probability and tn represents the next element in the sequence. LLaMA 2.2 Retriever Our retriever model, called RepLLaMA, follows the bi-encoder dense retriever architecture proposed in DPR (Karpukhin et al., 2020), but with the backbone model initialized with LLaMA. Previous work on dense retriever models often uses a bi-directional encoder-only model like BERT, taking the representation of the prepended [CLS] token as the dense representation of the text input. However, as LLaMA is uni-directional, we append an end-of-sequence token to the input query or document to form the input sequence to LLaMA. Thus, the vector embedding of a query or a document is computed as: where Decoder(·) represents the LLaMA model, which returns the last layer token representation for each input token. We take the representation of the end-of-sequence token as the representation of the input sequence t1 . . . tk, which can be either a query Q or a document D. Relevance of D to Q is computed in terms of the dot product of their corresponding dense representation VQ and VD as Sim(Q, D) =< VQ, VD >. The model is then optimized end-to-end according to InfoNCE loss: Here, D+ represents a document that is relevant to the query Q (based on human labels), while {DN } denotes a set of documents that is not relevant to the query. The set of negative documents includes both hard negatives, which are sampled from the top-ranking results of an existing retrieval system, and in-batch negatives, which are derived from the positive documents and hard negative documents associated with other queries in the same training batch. In practice, dense retrieval training tends to benefit from a larger set of hard negatives and in-batch negatives. During the inference phase, the query is typically encoded in real-time and the top-k similar documents are searched within the pre-encoded corpus using an efficient approximate nearest neighbour search library such as HNSW (Malkov and Yashunin, 2020). However, in this study, we opt to perform exact nearest neighbour search using flat indexes to evaluate model effectiveness. 2.3 Reranker Our reranker model, referred to as RankLLaMA, is trained as a pointwise reranker. This approach involves passing a query and a candidate document together as model input, with the model generating a score that indicates the relevance of the document to the query (Nogueira et al., 2019). In more detail, RankLLaMA reranks a query– document pair as follows: where Linear(·) is a linear projection layer that projects the last layer representation of the end-ofsequence token to a scalar. Similar to the retriever, the model is optimized by contrastive loss. However, in this case, the negative documents do not involve in-batch negatives. To train a reranker that is optimized to rerank candidates from a specific retriever in a multi-stage pipeline, hard negatives should be sampled from the top-ranking results from that retriever. Specifically, in our case, the hard negative training data for RankLLaMA are selected from the top-ranking results of RepLLaMA. During the inference stage, the top candidate documents retrieved by RepLLaMA are reordered. This reordering is based on the relevance score that RankLLaMA assigns to each query–document pair, with the documents arranged in descending order of relevance. This paper is available on arxiv under CC 4.0 license. This paper is available on arxiv under CC 4.0 license. available on arxiv

Optimizing Text Retrieval Pipelines with LLaMA Models

Authors:
(1) Xueguang Ma, David R. Cheriton School of Computer Science, University of Waterloo;
(2) Liang Wang, Microsoft Research;
(3) Nan Yang, Microsoft Research;
(4) Furu Wei, Microsoft Research;
(5) Jimmy Lin, David R. Cheriton School of Computer Science, University of Waterloo. Table of Links Abstract and Introduction Method Experiments Ablation Study and Analysis Related Work Conclusion, Acknowledgements and References Abstract The effectiveness of multi-stage text retrieval has been solidly demonstrated since before the era of pre-trained language models. However, most existing studies utilize models that predate recent advances in large language models (LLMs). This study seeks to explore potential improvements that state-of-the-art LLMs can bring. We conduct a comprehensive study, fine-tuning the latest LLaMA model both as a dense retriever (RepLLaMA) and as a pointwise reranker (RankLLaMA) for both passage retrieval and document retrieval using the MS MARCO datasets. Our findings demonstrate that the effectiveness of large language models indeed surpasses that of smaller models. Additionally, since LLMs can inherently handle longer contexts, they can represent entire documents holistically, obviating the need for traditional segmenting and pooling strategies. Furthermore, evaluations on BEIR demonstrate that our RepLLaMA–RankLLaMA pipeline exhibits strong zero-shot effectiveness. Model checkpoints from this study are available on HuggingFace.1 1 Introduction Text retrieval, which entails identifying and ranking the most relevant documents or text snippets in response to a query, is crucial in various opendomain language comprehension tasks (Petroni et al., 2021), including web search (Bajaj et al., 2016), open-domain question answering (Chen et al., 2017), and fact verification (Thorne et al., 2018). Retrieval also plays an important role in enhancing the effectiveness of large language models (LLMs) in a retrieval-augmented generation (RAG) pipeline (Lewis et al., 2020b; Shi et al., 2023). This approach not only mitigates hallucinations but also enables LLMs to access knowledge that is not captured within their parameters (Yang et al., 2023; Jiang et al., 2023). A typical multi-stage text retrieval pipeline consists of a retriever, designed to efficiently locate the top-k relevant texts from a corpus, and a reranker, which further refines the order of the retrieved candidates to improve output quality (Nogueira and Cho, 2019). Both retrievers and rerankers have significantly benefited from the advent of pre-trained language models based on Transformers (Vaswani et al., 2017) such as BERT (Devlin et al., 2019) and T5 (Raffel et al., 2020). These models are trained to encode queries and documents into vector representations for retrieval (Karpukhin et al., 2020; Lin, 2021) or to directly score the relevance between a query and a document for reranking (Nogueira et al., 2019; Zhuang et al., 2023). Recent large language models with billions of parameters, fine-tuned to follow instructions, such as InstructGPT (Ouyang et al., 2022), GPT-4 (OpenAI, 2023), and LLaMA (Touvron et al., 2023a,b), have exhibited extraordinary capabilities in many NLP tasks, surpassing previous smaller pre-trained language models (Zhao et al., 2023). For retrieval, recent methods such as LRL (Ma et al., 2023), RankGPT (Sun et al., 2023), and PRP (Qin et al., 2023) have explored prompting LLMs to perform zero-shot reranking using pairwise or listwise approaches. These methods leverage LLMs by viewing reranking as text generation. However, we see a number of potential issues. First, these methods do not address the entire multistage pipeline, as it is challenging to cast retrieval from a large corpus as a text generation task. Second, they do not leverage labeled data when available. Finally, these rerankers are not efficient because they do not support parallel scoring and are slowed by their multi-pass decoding design. Therefore, we argue that fine-tuning state-ofthe-art large language models to function as retrievers and rerankers can yield better effectiveness than previous smaller models. This approach can also optimally utilize LLMs within multi-stage pipelines. Thus, we are motivated to investigate the following research question: How do state-ofthe-art large language models perform when specifically fine-tuned for multi-stage text retrieval? Our study aims to answer this question by conducting a comprehensive investigation into finetuning the latest LLaMA-2 model (Touvron et al., 2023b), a state-of-the-art, open-source large language model, as both a retriever and a reranker, which we refer to as RepLLaMA and RankLLaMA, respectively. Specifically, we utilize the MS MARCO (Bajaj et al., 2016) and BEIR (Thakur et al., 2021) datasets for our experiments. Our findings suggest that large language models surpass previous smaller models, achieving state-of-the-art effectiveness for both retrieval and reranking through a straightforward training regime and exhibiting strong zero-shot effectiveness. Furthermore, we observe that LLMs, which are inherently pre-trained on longer contexts, demonstrate potential in representing entire documents, thereby eliminating the need for traditional segmenting and pooling strategies for document retrieval. This paper is available on arxiv under CC 4.0 license. 1 https://huggingface.co/castorini Authors: (1) Xueguang Ma, David R. Cheriton School of Computer Science, University of Waterloo; (2) Liang Wang, Microsoft Research; (3) Nan Yang, Microsoft Research; (4) Furu Wei, Microsoft Research; (5) Jimmy Lin, David R. Cheriton School of Computer Science, University of Waterloo. Authors: Authors: (1) Xueguang Ma, David R. Cheriton School of Computer Science, University of Waterloo; (2) Liang Wang, Microsoft Research; (3) Nan Yang, Microsoft Research; (4) Furu Wei, Microsoft Research; (5) Jimmy Lin, David R. Cheriton School of Computer Science, University of Waterloo. Table of Links Abstract and Introduction Abstract and Introduction Method Method Experiments Experiments Ablation Study and Analysis Ablation Study and Analysis Related Work Related Work Conclusion, Acknowledgements and References Conclusion, Acknowledgements and References Abstract The effectiveness of multi-stage text retrieval has been solidly demonstrated since before the era of pre-trained language models. However, most existing studies utilize models that predate recent advances in large language models (LLMs). This study seeks to explore potential improvements that state-of-the-art LLMs can bring. We conduct a comprehensive study, fine-tuning the latest LLaMA model both as a dense retriever (RepLLaMA) and as a pointwise reranker (RankLLaMA) for both passage retrieval and document retrieval using the MS MARCO datasets. Our findings demonstrate that the effectiveness of large language models indeed surpasses that of smaller models. Additionally, since LLMs can inherently handle longer contexts, they can represent entire documents holistically, obviating the need for traditional segmenting and pooling strategies. Furthermore, evaluations on BEIR demonstrate that our RepLLaMA–RankLLaMA pipeline exhibits strong zero-shot effectiveness. Model checkpoints from this study are available on HuggingFace.1 1 Introduction Text retrieval, which entails identifying and ranking the most relevant documents or text snippets in response to a query, is crucial in various opendomain language comprehension tasks (Petroni et al., 2021), including web search (Bajaj et al., 2016), open-domain question answering (Chen et al., 2017), and fact verification (Thorne et al., 2018). Retrieval also plays an important role in enhancing the effectiveness of large language models (LLMs) in a retrieval-augmented generation (RAG) pipeline (Lewis et al., 2020b; Shi et al., 2023). This approach not only mitigates hallucinations but also enables LLMs to access knowledge that is not captured within their parameters (Yang et al., 2023; Jiang et al., 2023). A typical multi-stage text retrieval pipeline consists of a retriever, designed to efficiently locate the top-k relevant texts from a corpus, and a reranker, which further refines the order of the retrieved candidates to improve output quality (Nogueira and Cho, 2019). Both retrievers and rerankers have significantly benefited from the advent of pre-trained language models based on Transformers (Vaswani et al., 2017) such as BERT (Devlin et al., 2019) and T5 (Raffel et al., 2020). These models are trained to encode queries and documents into vector representations for retrieval (Karpukhin et al., 2020; Lin, 2021) or to directly score the relevance between a query and a document for reranking (Nogueira et al., 2019; Zhuang et al., 2023). Recent large language models with billions of parameters, fine-tuned to follow instructions, such as InstructGPT (Ouyang et al., 2022), GPT-4 (OpenAI, 2023), and LLaMA (Touvron et al., 2023a,b), have exhibited extraordinary capabilities in many NLP tasks, surpassing previous smaller pre-trained language models (Zhao et al., 2023). For retrieval, recent methods such as LRL (Ma et al., 2023), RankGPT (Sun et al., 2023), and PRP (Qin et al., 2023) have explored prompting LLMs to perform zero-shot reranking using pairwise or listwise approaches. These methods leverage LLMs by viewing reranking as text generation. However, we see a number of potential issues. First, these methods do not address the entire multistage pipeline, as it is challenging to cast retrieval from a large corpus as a text generation task. Second, they do not leverage labeled data when available. Finally, these rerankers are not efficient because they do not support parallel scoring and are slowed by their multi-pass decoding design. Therefore, we argue that fine-tuning state-ofthe-art large language models to function as retrievers and rerankers can yield better effectiveness than previous smaller models. This approach can also optimally utilize LLMs within multi-stage pipelines. Thus, we are motivated to investigate the following research question: How do state-ofthe-art large language models perform when specifically fine-tuned for multi-stage text retrieval? Our study aims to answer this question by conducting a comprehensive investigation into finetuning the latest LLaMA-2 model (Touvron et al., 2023b), a state-of-the-art, open-source large language model, as both a retriever and a reranker, which we refer to as RepLLaMA and RankLLaMA, respectively. Specifically, we utilize the MS MARCO (Bajaj et al., 2016) and BEIR (Thakur et al., 2021) datasets for our experiments. Our findings suggest that large language models surpass previous smaller models, achieving state-of-the-art effectiveness for both retrieval and reranking through a straightforward training regime and exhibiting strong zero-shot effectiveness. Furthermore, we observe that LLMs, which are inherently pre-trained on longer contexts, demonstrate potential in representing entire documents, thereby eliminating the need for traditional segmenting and pooling strategies for document retrieval. This paper is available on arxiv under CC 4.0 license. This paper is available on arxiv under CC 4.0 license. available on arxiv 1 https://huggingface.co/castorini

Fine-Tuning LLaMA for Multi-Stage Text Retrieval

মাল্টি-স্টেজ টেক্সট পুনরুদ্ধারের জন্য ফাইন-টিউনিং LLaMA

Feinabstimmung von LLaMA für mehrstufigen Textabruf

Ajuste fino de LLaMA para la recuperación de texto en varias etapas

Affiner LLaMA pour la récupération de texte en plusieurs étapes

बहु-चरणीय पाठ पुनर्प्राप्ति के लिए LLaMA को परिष्कृत करना

多段階テキスト検索のための LLaMA の微調整

다단계 텍스트 검색을 위한 LLaMA 미세 조정

LLaMA de ajuste fino para recuperação de texto em vários estágios

Точная настройка LLaMA для многоэтапного поиска текста

Çok Aşamalı Metin Erişimi için LLaMA'nın İnce Ayarı

Tinh chỉnh LLaMA để truy xuất văn bản nhiều giai đoạn

用于多阶段文本检索的微调 LLaMA

As an AI startup founder, you likely know how impactful large language models like ChatGPT have been in advancing conversational AI. However, with commercial licensing costs, censorship issues, degraded performance, privacy concerns, and black boxes, these proprietary models remain out of reach for many startups. This is where an open-source project called Vicuna comes in. Developed by a team of researchers from institutions like Stanford, Vicuna is conversational model achieving over 90% of ChatGPT's quality. This makes it an exciting alternative to closed-off models like GPT-4. an open-source Subscribe or follow me on Twitter for more content like this! In this article, we'll explore what Vicuna is, how it works, its capabilities, and how you may be able to leverage it as an AI founder. We'll see how it stacks up to competitors like ChatGPT and the base LLaMA model. I'll also share some helpful tips and guides you can follow for more information about specific aspects of the model. We will concentrate on Vicuna-13b for this article, but there are many different-sized models of Vicuna out there for you to try. Let's begin! Note: Vicuna isn't the only model out there to fine-tune LLaMA for chat. Check out our guides on using , LLaMA v2 , and Alpaca LLaMA-v2-chat for conversational applications. An Overview of Vicuna In the world of conversational AI, we've seen astounding progress recently with models like ChatGPT demonstrating remarkable natural language abilities. However, as a proprietary model with all the issues described above, ChatGPT remains a bad option for many developers. So there's a need for more accessible and open models that can empower innovation in conversational apps. This is where Vicuna comes in. Developed by researchers like Stanford, Berkeley, and MBZUAI, Vicuna represents cutting-edge open conversational AI. from leading institutions It was created by fine-tuning the LLaMA model on curated dialog data, demonstrating the power of transfer learning from an open-source foundation model. Despite being smaller in size than ChatGPT, Vicuna matches its conversational quality and significantly outperforms other open models. But it's not just about the technology with Vicuna. What makes it truly impactful is its availability under a non-commercial research license. This opens up access to state-of-the-art conversational AI that was previously restricted to only large tech companies. We finally have an open model that can power the next generation of chatbots, virtual assistants, conversational search engines, and other innovative applications. Vicuna's promise has already been demonstrated through cool projects that leverage it. For example, used Vicuna to build an intelligent virtual assistant, created a conversational search engine with it, and taps Vicuna's abilities for natural language content creation. MiniGPT4 LLaVA ToolLLaMA And, of course, you may add your own project to this list one day! For AI developers and startups, Vicuna represents an exciting new opportunity. Its high capability, free availability, and permissive research license enable rapid prototyping of conversational apps. Instead of being gated by access to proprietary models, startups can now validate and build products with cutting-edge conversational AI. The playing field just got leveled. So, in summary, Vicuna promises to democratize access to top-tier conversational intelligence. Its emergence represents an important milestone in making open AI models that empower innovation. For any startup looking to leverage conversational AI, Vicuna is definitely a project worth paying attention to! How Was Vicuna Created? What Makes It Special? The story of Vicuna begins with LLaMA, an open-source language model developed by Meta AI. While capable, LLaMA had no inherent conversational abilities, focusing mainly on language itself rather than the art of conversation. Researchers from institutions including Stanford, Berkeley, and MBZUAI set out to change this. Their goal was to create an open-source conversational model rivaling proprietary chatbots like ChatGPT. By the way, what's the difference between an AI model trained to process and analyze text (like LLaMA) versus one specialized for chat (like Vicuna)? There are a few key factors that differentiate the two: - Conversational models like Vicuna have an encoder-decoder structure optimized for dialog. The encoder contextualizes the conversation history and current user input. The decoder then generates a relevant response. General language models like LLaMA lack this specialized architecture. Architecture - Models like Vicuna are fine-tuned to maximize performance specifically on conversational tasks. This involves training on dialog datasets to optimize conversational metrics. LLaMA is trained more generally for text, not specialized for dialog. Training Objective - Conversational models need to handle multi-turn conversations, maintaining context and coherency across multiple exchanges. General text models evaluate one input at a time. Multi-Turn Capabilities - Conversational AI needs to fluidly interact with users, responding to follow-up questions and clarifications. Text evaluation is more passive, lacking user interactivity. Interactivity - Conversational models require more complex evaluation beyond text metrics, testing qualities like consistency, nuance, and the ability to gracefully handle inappropriate responses. Evaluation Whereas a general language model like LLaMA focuses more on textual analysis and generation, without the requirements specific to dialog agents, the goal of conversational AI is fundamentally more complex than passive text evaluation. To that end, the researchers who created Vicuna fine-tuned LLaMA on over 70,000 human-ChatGPT dialog exchanges, specializing the model for conversation and teaching it the natural characteristics of text in conversational contexts. This fine-tuning was crucial for giving their version of LLaMA the conversational intelligence it previously lacked. Through iterative training on the dialog data, LLaMA was transformed into Vicuna, an encoder-decoder transformer optimized for multi-turn conversations. How well did their efforts work? Into the Arena: Evaluating Vicuna Against Alternative Chat AI Models To evaluate Vicuna's capabilities, the researchers tested it on 200 diverse conversational prompts. For further assessment, they had the GPT-4 model comparatively judge Vicuna's responses. The results demonstrated that Vicuna achieved over 90% of ChatGPT's quality in conversational ability, despite being smaller in size. It significantly outperformed the original LLaMA model. By combining architecture optimizations with specialized fine-tuning on human dialog data, the researchers successfully enhanced LLaMA into an open-source conversational model on par with proprietary chatbots. Let's take a look at a head-to-head test as an example, taken from the . official project site Example head-to-head challenge between Vicuna and competitor models, in this case, using ChatGPT-3.5 as a potential alternative. The project site has a collection of example tasks, in which both Vicuna-13b and competing models are asked to go head-to-head. The GPT-4 model is then used as a judge to score each model and state its reasoning. This produces some really eye-opening comparisons. One example is provided in the image above. Another is this challenge, shown below: Roleplay Category: How would you introduce yourself as a medieval knight at a royal banquet? Question: LLaMA-13b's response: "I am a valiant knight, loyal to the king. I will do my utmost to defend his honor and protect his country. (Lame! Scored 7/10 by GPT-4, very generous in my opinion.)" Vicuna-13b: **"**As a medieval knight, I would introduce myself at a royal banquet with a deep bow and a respectful speech, acknowledging my humble origins and my loyalty to the crown. I would say something like: "My lords and ladies, I am a humble knight, sworn to serve and protect the realm. I come from a long line of warriors who have fought to defend this kingdom for generations. I am honored to be here today, in the presence of such esteemed company, and I hope to earn your trust and respect with my deeds and actions. I pledge my sword, my shield, and my life to the service of my king and my people." I would then take my seat at the banquet, ready to listen and learn from the wise counsel of my betters, and to serve them in any way I can." Woah! Way better response from Vicuna. Here's GPT-4's reasoning explaining what makes Vicuna a superior alternative to LLaMA. provided a brief and relevant response, but it lacked the detail and formality expected in a medieval knight's introduction. , on the other hand, offered a more comprehensive and well-structured response, including a respectful speech that showcased the knight's humility, loyalty, and dedication to the kingdom. This response was more fitting for the context of a royal banquet and demonstrated a better understanding of the medieval knight's role and etiquette. Assistant 1 [LLaMA] Assistant 2 [Vicuna] While LLMs are not infallible judges of other LLMs, neither are humans. I think the use of AI to judge and evaluate AI is a pretty scalable and consistent way to adjudicate which alternatives are the best. You should check out some of the other competitor answers and tasks on the . LMSYS.org site Let's Try It Ourselves: How to Build a Basic Chatbot With Vicuna Now that we've seen how the model stacks up against some alternatives, let's see how we can build a simple chatbot that we can interact with from our command line. The steps in the guide provided here can be further expanded so you can keep going and build your own chatbot for your AI project! Step 1: Setup : Make sure is installed on your system. Install Node.js Node.js : Run the following in your terminal: Create a Project Directory mkdir my-chatbot
cd my-chatbot
npm init -y
npm install replicate : Replace with your actual API token: Set Your API Token your_api_token_here export REPLICATE_API_TOKEN=your_api_token_here Step 2: Writing the Chatbot Code Create a file named , and add the following code: chatbot.js const Replicate = require("replicate");

const replicate = new Replicate({
  auth: process.env.REPLICATE_API_TOKEN,
});

async function generateResponse(prompt) {
  const output = await replicate.run(
    "replicate/vicuna-13b:version_hash_here",
    {
      input: { prompt: prompt },
    }
  );
  return output.items[0];
}

const readline = require('readline');
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

function askQuestion() {
  rl.question('You: ', async (userInput) => {
    const botResponse = await generateResponse(userInput);
    console.log(`Bot: ${botResponse}`);
    askQuestion();
  });
}

askQuestion(); Replace with the correct version hash for the Vicuna 13b model. version_hash_here Step 3: Running the Chatbot Run the chatbot by executing: node chatbot.js You can now send a message to your chatbot through the command line! Don't want to build your own chatbot? You can use this demo to assess how Vicuna performs. The includes a couple of demos you can use to play around with the model. Here's an embedded one for you to try (you can also use to access it if it's not available at the link below). model details page for Vicuna-13b-v1.3 this link This demo, build by zeno-ml, lets you compare models and additional parameters to see how well Vicuna performs against competitors like LLaMA, GPT2, and MPT while also varying temperature or other parameters. Vicuna's Limitations While conversational technologies have advanced rapidly, models still face important challenges. Conversational agents lack sufficient grounding in real factual knowledge, making them prone to plausible-sounding but incorrect responses. More grounding in the real world could improve accuracy. One issue is knowledge grounding. Performing logical reasoning, causal inference, and mathematical operations remains difficult for chatbots. Their reasoning capabilities are still limited. Reasoning abilities are another area for improvement. Current solutions like asking a separate AI judge have flaws. Developing rigorous evaluation frameworks is an open problem. Evaluating the conversational quality of AI systems at scale also poses difficulties. Conversational models can sometimes behave inappropriately or unsafely. Better training data curation is important. Additionally, biases and safety issues persist due to reliance on imperfect training data. still proves challenging too. More personalization and customization is needed for different domains. You can't do this out of the box easily. Adapting chatbots to specific users and use cases While great progress has been made, these limitations highlight key areas for improvement. Advancing knowledge grounding, reasoning, evaluation, training data, customization, and deployment efficiency could enable the next level of conversational intelligence with models like Vicuna. Conclusion: Using Vicuna AI as an Open-Source Alternative to ChatGPT, LLaMA, and Other LLMs The development of Vicuna demonstrates promising progress in advancing open-source conversational AI. By fine-tuning the LLaMA model architecture and training methodology specifically for dialog applications, researchers were able to create a freely available conversational agent competitive with leading proprietary alternatives. However, work remains to be done to address limitations around reasoning, evaluation, customization, and other areas. While models like Vicuna achieve strong results on many benchmarks, they do not fully replicate comprehensive human conversation. Ongoing research on aligning these models will be important. Nonetheless, Vicuna represents a valuable step forward in democratizing access to state-of-the-art conversational intelligence. For startups and developers building chatbots, assistants, and other applications, open-source options like Vicuna provide welcome capabilities without restrictive commercial licensing. The origins and technical details behind Vicuna offer useful insights into specialized training approaches for conversational AI. As research continues, we can expect to see further innovations that build on these methods. The authors behind Vicuna have made an important contribution to open-sourcing such a capable dialog agent. While more progress is still needed, Vicuna demonstrates the meaningful results that can come from developing open conversational models. For the AI community, it represents a promising step, not the final destination. With continued work on advancing these technologies, the potential ahead remains exciting. Subscribe or follow me on Twitter for more content like this! Further Reading and Resources You might find these other articles helpful in your quest to build the ultimate chatbot for your new product or project. - An overview of Vicuna with basic model info Vicuna-13b model details - An article on using Vicuna to create chatbots Building chatbots with Vicuna-13B -  A comparison between LLaMA's new version 2 and Vicuna Comparing LLMs for chat: LLaMA v2 vs Vicuna - LangChain is a popular framework for building chat applications LangChain chat models: an overview Also published here

Vicuna: How Does It Compare to Llama, Alpaca, and ChatGPT?

ভিকুনা: এটি লামা, আলপাকা এবং চ্যাটজিপিটির সাথে কীভাবে তুলনা করে?

Vicuna: Wie schneidet es im Vergleich zu Lama, Alpaka und ChatGPT ab?

Vicuña: ¿Cómo se compara con Llama, Alpaca y ChatGPT?

Vicuna : Comment se compare-t-il à Llama, Alpaca et ChatGPT ?

विकुना: इसकी तुलना लामा, अल्पाका और चैटजीपीटी से कैसे की जाती है?

ビクーニャ: ラマ、アルパカ、ChatGPT とどう違うのですか?

Vicuna: Llama, Alpaca 및 ChatGPT와 어떻게 비교됩니까?

Vicunha: Como se compara a Llama, Alpaca e ChatGPT?

Vicuna: Lama, Alpaka ve ChatGPT ile Nasıl Karşılaştırılır?

Vicuna: Nó so sánh với Llama, Alpaca và ChatGPT như thế nào?

Vicuna：它与 Llama、Alpaca 和 ChatGPT 相比如何？

AI language models have revolutionized the field of natural language processing, enabling a wide range of applications such as chatbots, text generation, and language translation. In this blog post, we will explore two powerful AI models: and . These models are fine-tuned language models that excel in chat completions and have been trained on vast amounts of textual data. By comparing and understanding these models, we can leverage their capabilities to solve various real-world problems. llama13b-v2-chat vicuna-13b Introducing llama13b-v2-chat and vicuna-13b The llama13b-v2-chat model, developed by , is a 13 billion parameter language model fine-tuned for chat completions. It provides accurate and contextually relevant responses to user queries, making it ideal for interactive conversational applications. With its impressive capacity, llama13b-v2-chat can understand and generate human-like text responses. You can find more information about this model . a16z-infra here On the other hand, vicuna-13b is an open-source chatbot based on LLaMA-13B. It has been fine-tuned on ChatGPT interactions, ensuring its high performance in generating coherent and engaging responses. The implementation of vicuna-13b we'll be looking at was developed by and offers an effective solution for creating conversational agents, virtual assistants, and other interactive chat applications. Replicate Understanding the llama13b-v2-chat Model The llama13b-v2-chat model, created by a16z-infra, stands out for its extensive language comprehension and generation capabilities. With 13 billion parameters, it has been fine-tuned specifically for chat completions, allowing it to excel in generating contextually relevant responses. You can learn more about the model and its creator by visiting the and the . llama13b-v2-chat creator detail page llama13b-v2-chat model detail page In simpler terms, the llama13b-v2-chat model can understand user prompts and generate human-like text responses based on the provided context. It uses its vast knowledge and language understanding to create coherent and relevant chat interactions. By leveraging this model, developers can build chatbots, virtual assistants, and other conversational applications that can engage users in natural and interactive conversations. Understanding the vicuna-13b Model The vicuna-13b model, developed by Replicate, is a fine-tuned language model based on LLaMA-13B. It has been optimized for chat-based applications, providing accurate and contextually appropriate responses. To learn more about the vicuna-13b model and its creator, you can visit the and the . vicuna-13b creator detail page vicuna-13b model detail page In simple terms, the vicuna-13b model is an AI language model that generates text responses based on user prompts. It has been trained on a large corpus of text data and fine-tuned to excel in chat-based interactions. By leveraging the vicuna-13b model, developers can create chatbots, virtual assistants, and other conversational agents that can understand and respond to user queries in a natural and contextually appropriate manner. Understanding the Inputs and Outputs of the Models To better understand how these models work, let's dive into the inputs and outputs they accept and produce. Inputs of the Llama13b-v2-chat Model A string that represents the user's input or query. Prompt: An optional parameter that determines the maximum number of tokens in the generated response. Max Length: A parameter that controls the randomness of the model's output. Higher values lead to more diverse responses, while lower values make the responses more deterministic. Temperature: A parameter that influences the diversity of the generated text by sampling from the top percentage of likely tokens. Top-p: A parameter that penalizes or encourages repeated words in the generated text. Repetition Penalty: An optional parameter that provides debugging output in logs. Debug: Outputs of the Llama13b-v2-chat Model The output of the llama13b-v2-chat model is an array of strings, representing the generated text responses. The model's responses are coherent and relevant to the user's input, providing valuable information or engaging in interactive conversations. Inputs of the Vicuna-13b Model A string representing the user's input or query. Prompt: An optional parameter that defines the maximum number of tokens in the generated response. Max Length: A parameter that controls the randomness of the model's output. Higher values result in more diverse responses, while lower values make the responses more deterministic. Temperature: A parameter that influences the diversity of the generated text by sampling from the top percentage of likely tokens. Top-p: A parameter that penalizes or encourages repeated words in the generated text. Repetition Penalty: An optional parameter that sets the seed for the random number generator, enabling reproducibility. Seed: An optional parameter that provides debugging output in logs. Debug: Outputs of the Vicuna-13b Model The output of the vicuna-13b model is an array of strings, representing the generated text responses. These responses are contextually relevant and provide meaningful information or engage in interactive conversations based on the user's input. Comparing and Contrasting the Models Now that we have explored both models individually, let's compare and contrast them to understand their use cases, strengths, and differences. Use Cases and Pros and Cons Both the llama13b-v2-chat and vicuna-13b models have distinct use cases and offer unique advantages: This model excels in chat-based applications, making it ideal for creating interactive conversational agents, chatbots, and virtual assistants. Its 13 billion parameters enable accurate and contextually relevant responses, engaging users in natural and interactive conversations. llama13b-v2-chat: Also designed for chat-based interactions, the vicuna-13b model performs exceptionally well in generating coherent and contextually appropriate responses. It is suitable for developing conversational agents, chatbots, and virtual assistants that can provide meaningful and accurate information to users. vicuna-13b: While both models offer similar functionalities, they have differences that can influence their optimal applications: This model provides a lower cost per run compared to vicuna-13b, making it an attractive option for projects with cost constraints. It also offers faster average completion times, delivering prompt responses for chat-based applications. llama13b-v2-chat: Although vicuna-13b has a slightly higher cost per run and average completion time compared to llama13b-v2-chat, it compensates with its performance, reaching 90% of the quality of OpenAI's ChatGPT and Google Bard. If the highest quality and performance are crucial for your project, vicuna-13b might be the preferred choice. vicuna-13b: When to Use Each Model Choosing the right model depends on your specific requirements and project goals. Here are some guidelines: Use when: llama13b-v2-chat Cost efficiency is a priority. Fast response times are essential. Engaging in interactive chat conversations is the primary focus. Use when: vicuna-13b High performance and quality are critical. Budget allows for a slightly higher cost per run. Contextually accurate and engaging responses are necessary. Remember that both models are versatile and can be adapted to various applications. Consider your project's unique needs and preferences when deciding which model to use. Taking it Further - Finding Other AI Models with AIModels.fyi If you're interested in finding similar models to llama13b-v2-chat and vicuna-13b or exploring other AI models for different creative needs, AIModels.fyi is an excellent resource to discover and compare AI models. AIModels.fyi is a fully searchable and filterable database of models, allowing you to find models that cater to your specific requirements. Here's how you can use AIModels.fyi to explore similar models: Step 1: Visit AIModels.fyi Head over to AIModels.fyi to begin your search for similar models. Step 2: Use the Search Bar Utilize the search bar at the top of the page to search for models using specific keywords related to your needs. For example, you can search for models in the text-to-text category or models specifically fine-tuned for chat completions. Step 3: Filter the Results On the left side of the search results page, you'll find various filters to narrow down the list of models. You can filter and sort models by type (e.g., Image-to-Image, Text-to-Image), cost, popularity, or even specific creators. By applying these filters, you can find models that best suit your needs and preferences. By leveraging AIModels.fyi, you can discover a vast range of AI models and explore their capabilities, enabling you to broaden your horizons in the world of AI-powered applications. Conclusion In this guide, we compared and contrasted two powerful AI language models: llama13b-v2-chat and vicuna-13b. We explored their use cases, strengths, and differences, helping you understand when each model would be the optimal choice for your projects. Additionally, we introduced AIModels.fyi as a valuable resource for discovering and comparing AI models, providing you with the means to find similar models and explore new possibilities in the world of AI. I hope this guide has inspired you to explore the creative possibilities of AI and leverage the capabilities of models like llama13b-v2-chat and vicuna-13b. By utilizing AIModels.fyi, you can stay up-to-date with new and improved AI models, access a wealth of resources and guides, and find inspiration for your next creative project. Don't forget to subscribe to AIModels.fyi for more tutorials, updates, and inspiration. Feel free to connect with me on Twitter for further discussions and insights. Happy exploring!

Comparing LLMs for Chat Applications: Llama v2 Chat vs. Vicuna

Think about the complexities of generating human-like responses in online chat applications. How can you make infrastructure efficient and responses realistic? The solution is AI language models. In this guide, we delve into the a16z-infra's implementation of 's new LLM, a 13-billion-parameter language model fine-tuned specifically for chat applications. This model is hosted on Replicate, an AI model hosting service that allows you to interact with complicated and powerful models with just a few lines of code or a simple API call. Meta llama13b-v2-chat In this guide, we'll cover what the llama13b-v2-chat model is all about, how to think about its inputs and outputs, and how to use it to create chat completions. We'll also walk you through how to find similar models to enhance your AI applications using . So let's slice through the AI jargon and get to the core. AIModels.fyi or follow me on Subscribe Twitter for more content like this! About the LLaMA-v2 chat model The model available on Replicate was created by the and is built on top of Meta's new LLaMA v2 model. Meta created LLaMA with the aim of better understanding and generating human language, and the chat model we'll examine has been further fine-tuned to improve interactions between human users and AI chatbots. With a whopping 13 billion parameters, this model has been tailored significantly for this specific use-case. You can find more details about this model and the other models by a16z-infra at the on . LLaMA13b-v2-chat a16z-infra team creator's page AIModels.fyi The Replicate implementation of the llama13b-v2-chat model uses the powerful Nvidia A100 (40GB) GPU for predictions, with an average run time of 7 seconds per prediction. It is priced at a mere $0.014 per run, which makes it widely accessible for lower-budget projects or startups. Understanding the Inputs and Outputs of the LLaMA v2 Chat Understanding what goes into and comes out of a model is key to leveraging its capabilities effectively. So let's get familiar with the inputs and outputs for the model. Inputs The model accepts the following inputs: (string): The prompt to send to Llama v2. prompt (integer): The maximum number of tokens to generate. Keep in mind, a word is generally 2-3 tokens. Default value is 500. max_length (number): Adjusts the randomness of outputs. Greater than 1 is random and 0 is deterministic. A good starting value is 0.75. temperature (number): During text decoding, it samples from the top p percentage of most likely tokens. Lower this to ignore lesser likely tokens. The default value is 1. top_p (number): Provides penalty for repeated words in generated text. 1 is no penalty. Values greater than 1 discourage repetition, less than 1 encourage it. repetition_penalty (boolean): Used to provide debugging output in logs. debug Note that the creators of the model recommend that you follow this structure when creating your prompt: User: <your prompt goes here>
Assistant: For example... User: give me tips on things to do in Maine
Assistant: Outputs of the Model The model produces the following output: A raw JSON schema, cataloguing the output structure - an array of strings to be used for further computation or user interface. Here's an example of the output schema: {
  "type": "array",
  "items": {
    "type": "string"
  },
  "title": "Output",
  "x-cog-array-type": "iterator",
  "x-cog-array-display": "concatenate"
} Now, let's transition to the nitty-gritty of how to use this model. Using LLaMA v2 Chat to Generate Natural Chat Completions Whether you're a novice dabbling in code, or you're a seasoned veteran, using the llama13b-v2-chat model to create realistic chat completions can be pretty fun. to interact with the model's interface and understand its workings if you're just playing around and want to get a feel for how it works. Once you're ready to implement it into your project, follow the steps below. Use this demo link Firstly, you'll need to set up your environment by installing the Node.js client: npm install Replicate Next, authenticate your API token and set it as an environment variable. This token is personal, and therefore should be kept confidential: export REPLICATE_API_TOKEN=r8_****** Then, you can run the model with the following script: import Replicate from "replicate";

const replicate = new Replicate({
  auth: process.env.REPLICATE_API_TOKEN,
});

const output = await replicate.run(
  "a16z-infra/llama13b-v2-chat:df7690f1994d94e96ad9d568eac121aecf50684a0b0963b25a41cc40061269e5",
  {
    input: {
      prompt: "..."
    }
  }
); You can also set a webhook to be called when your prediction is complete. This could be beneficial in maintaining logs or setting up automatic alerts. const prediction = await replicate.predictions.create({
  version: "df7690f1994d94e96ad9d568eac121aecf50684a0b0963b25a41cc40061269e5",
  input: {
    prompt: "..."
  },
  webhook: "https://example.com/your-webhook",
  webhook_events_filter: ["completed"]
}); For more details, you can always refer to the documentation on . Replicate Taking it Further: Finding Other Text-to-Text Models with AIModels.fyi Want to explore some other chatbots for your application? Finding similar models to llama13b-v2-chat is easy when you're using . AIModels.fyi Here's a step-by-step guide to help you find other AI models that cater to your specific needs: Step 1: Visit AIModels.fyi Head over to to begin your exploration. AIModels.fyi Step 2: Use the Search Bar Type in key phrases such as "text-to-text", "language models", etc. The search engine will furnish a list of models fitting your query. Step 3: Filter the Results Filters to narrow down your search can be found on your search results page. You can filter and sort the models by type, cost, popularity, or even by specific creators. For instance, if you're looking for a budget-friendly text-to-text model, you can sort models by price to find the cheapest option. Conclusion In this guide, we explored the potential of LLaMA v2, a feature-rich, cost-effective language model. It's the potential backbone for your next chat application, powering nuanced and realistic conversation. You now know how to implement this model, understand its inputs/outputs, and effectively generate relevant chat completions. You might find these other guides helpful as you continue to build your knowledge: LangChain Chat Models: An Overview Building a Customer Support Chatbot with LangChain and DeepInfra: A Step-by-Step Guide By taking your imagination and welding it with these AI tools, you launch yourself into the vast universe of artificial intelligence, creating new and exciting projects. We're excited to see where you'll go next. Don't forget to subscribe for more tutorials, to keep up-to-date on new and improved AI models, and feed your creativity for your next AI project. Till then, happy AI adventuring and remember to say hello on . my twitter or follow me on Subscribe Twitter for more content like this!

A Deep Dive into LLaMA v2 for Chat Applications

চ্যাট অ্যাপ্লিকেশনের জন্য LLaMA v2 এ গভীরভাবে ডুব দিন

Ein tiefer Einblick in LLaMA v2 für Chat-Anwendungen

Una inmersión profunda en LLaMA v2 para aplicaciones de chat

Une plongée profonde dans LLaMA v2 pour les applications de chat

चैट अनुप्रयोगों के लिए LLaMA v2 में एक गहन जानकारी

チャット アプリケーション用の LLaMA v2 の詳細

채팅 애플리케이션용 LLaMA v2 심층 분석

Um mergulho profundo no LLaMA v2 para aplicativos de bate-papo

Sohbet Uygulamaları için LLaMA v2'ye Derin Bir Bakış

Đi sâu vào LLaMA v2 cho các ứng dụng trò chuyện

深入探讨聊天应用程序的 LLaMA v2

LLMs have revolutionized tons of aspects of our lives, from language generation to software to friendly chatbots. These AI models provide powerful tools for solving real-world problems, such as generating chat responses or following complex instructions. image captioning In this blog post, part of a on , we will compare two popular AI models: llama13b-v2-chat and Alpaca, and explore their features, use cases, and limitations. series LLaMA v2 We'll also see how we can use to find similar models and compare them to llama13b-v2-chat and Alpaca. Let's begin. AIModels.fyi About the LLaMA13b-v2-chat Model The llama13b-v2-chat model is a fine-tuned version of the 13-billion-parameter LLaMA-v2 language model originally developed by Meta. It has been fine-tuned specifically for chat completions, making it an excellent tool for generating chat responses to user messages. You can find detailed information about the model on the and the . llama13b-v2-chat creator page llama13b-v2-chat model detail page This language model is designed to assist in generating text-based responses for chat-based interactions. Whether it's providing customer support, generating conversational agents, or assisting in natural language understanding tasks, llama13b-v2-chat can be a valuable tool. Its large parameter size enables it to capture complex language patterns and generate coherent and contextually relevant responses. In summary, llama13b-v2-chat can understand inputs and generate appropriate chat responses. Understanding the Inputs and Outputs of the llama13b-v2-chat Model To effectively use the llama13b-v2-chat model, it's essential to understand its inputs and outputs. The model accepts the following inputs: : A string representing the chat prompt or query. Prompt : An integer specifying the maximum number of tokens to generate. Max Length : A number that adjusts the randomness of outputs. Higher values (greater than 1) result in more random responses, while lower values (closer to 0) produce more deterministic outputs. Temperature : When decoding text, samples from the top p percentage of the most likely tokens. Lower values limit the sampling to more likely tokens. Top P : A number that penalizes the repetition of words in the generated text. Higher values discourage repetition, while values less than 1 encourage it. Repetition Penalty : A boolean flag to provide debugging output in logs. Debug The model processes these inputs and generates a list of strings as output, representing the generated chat responses. The schema for the output is a JSON array containing strings. You can find out more about this model in the guides and . here here About the Alpaca Model The Alpaca model is an instruction-following language model fine-tuned from the LLaMA 7B model on 52K instruction-following demonstrations. It was developed by the Stanford Center for Research on Foundation Models (CRFM). The creators of Alpaca are Rohan Taori, Ishaan Gulrajani, Tianyi Zhang, Yann Dubois, Xuechen Li, Carlos Guestrin, Percy Liang, and Tatsunori B. Hashimoto. You can find detailed information about the model on the the team created. Stanford page The Alpaca model focuses on instruction-following capabilities and aims to bridge the gap between research and industry by providing an accessible instruction-following language model for academic purposes. It is fine-tuned from the LLaMA 7B model using a dataset of 52K instruction-following demonstrations, generated in the style of self-instruct using text-davinci-003. The model demonstrates promising performance in single-turn instruction following. This model's release is intended to facilitate academic research and foster improvements in instruction-following models. It is important to note that Alpaca is not designed for commercial use, and its safety measures are not fully developed for general deployment. In summary, Alpaca offers a lightweight and reproducible instruction-following language model that can be utilized for research purposes and the exploration of instruction-following scenarios. https://notes.aimodels.fyi/content/images/2023/07/alpaca_main-1.jpeg How the Alpaca model works, from the official website. Understanding the Inputs and Outputs of the Alpaca Model To effectively utilize the Alpaca model, let's explore its inputs and outputs. As an instruction-following model, Alpaca follows instructions and generates responses based on the given instructions. The inputs to Alpaca are represented by the instructions themselves, which describe the tasks the model should perform. Alpaca also has an optional input field, providing additional context or input for the task. The outputs of the Alpaca model are the generated responses to the given instructions. The responses are generated based on the fine-tuned model's understanding of the task and the underlying language patterns learned during training. You can read more about this in the model's README on . GitHub Comparing and Contrasting the Models Now that we have explored the llama13b-v2-chat model and the Alpaca model in detail, let's compare and contrast them to understand their similarities, differences, and optimal use cases. LLaMA13-v2 vs Alpaca Both the llama13b-v2-chat and Alpaca models are fine-tuned language models designed for different purposes. While llama13b-v2-chat focuses on chat completions, Alpaca specializes in instruction-following tasks. Use Cases The llama13b-v2-chat model is suitable for a wide range of chat completion tasks. It can be utilized in customer service applications, chatbot development, dialogue generation, and interactive conversational systems. This model's versatility allows it to generate coherent and contextually relevant responses to user queries or prompts. On the other hand, the Alpaca model is specifically tailored for instruction-following tasks. It excels at understanding and executing instructions provided by users, making it ideal for applications such as virtual assistants, task automation, and step-by-step guidance systems. Alpaca's ability to comprehend and follow instructions makes it a valuable tool for users seeking assistance in performing various tasks. Pros and Cons The llama13b-v2-chat model's strengths lie in its large parameter size (13 billion) and its fine-tuning for chat completions. It can generate detailed and contextually appropriate responses, making it useful for engaging and interactive conversational experiences. However, due to its generic nature, the model might occasionally produce responses that are factually incorrect or propagate stereotypes. Careful monitoring and filtering mechanisms should be implemented to mitigate these risks. Alpaca, on the other hand, offers a smaller and more cost-effective model (7B parameters) that is specifically optimized for instruction-following. It demonstrates performance comparable to the text-davinci-003 model in this domain. Alpaca's relative ease of reproducibility and lower cost make it an attractive option for academic researchers interested in instruction-following models. However, it shares common limitations of language models, including occasional hallucinations and the potential to generate false or misleading information. Similarities Both models are built upon the LLaMA framework, which provides a strong base language model for fine-tuning. They leverage the power of large-scale language models to generate high-quality outputs. Additionally, both models have been evaluated and compared to the text-DaVinci-003 model, showcasing their ability to perform similarly in instruction-following tasks. Differences The primary difference between the models lies in their intended use cases and specialties. While llama13b-v2-chat is a versatile chat completion model suitable for various conversational applications, Alpaca is specifically designed for instruction-following tasks. Alpaca's training data is generated based on self-instructed prompts, enabling it to comprehend and execute specific instructions effectively. Optimal Use Cases Choosing between the llama13b-v2-chat and Alpaca models depends on the specific requirements of your project or application. If your goal is to develop a conversational system or chatbot that engages in dynamic and context-aware conversations, llama13b-v2-chat would be a better choice. On the other hand, if you need a model that can understand and execute user instructions for task-oriented applications, Alpaca is the more suitable option. Taking it Further - Finding Other Instruction-Following or Chat Models with AIModels.fyi If you're interested in exploring additional instruction-following models beyond Alpaca, is a valuable resource. It offers a comprehensive database of AI models, including those catered to instruction-following tasks. AIModels.fyi By following these steps, you can discover similar models and compare their outputs: - Head over to to begin your search for instruction-following models. Step 1: Visit AIModels.fyi AIModels.fyi Utilize the search bar at the top of the page to enter specific keywords related to instruction-following models. This will provide you with a list of models relevant to your search query. Step 2: Use the Search Bar - On the left side of the search results page, you'll find various filters to narrow down the models. You can filter and sort by model type, cost, popularity, and specific creators. Apply these filters to find models that align with your requirements. Step 3: Filter the Results - By leveraging the search and filter features on , you can find models that best suit your needs and explore the diverse landscape of instruction-following models. AIModels.fyi Conclusion In this comparison, we explored the llama13b-v2-chat and Alpaca models in terms of their use cases, pros and cons, similarities, differences, and optimal applications. We emphasized the versatility of llama13b-v2-chat for chat completions and the specialization of Alpaca for instruction-following tasks. serves as a valuable resource for discovering and comparing various AI models, including instruction-following models. AIModels.fyi We hope this guide inspires you to explore the creative possibilities of AI and encourages you to leverage to find models that align with your specific needs. AIModels.fyi Remember to subscribe for more tutorials, updates on new AI models, and a wealth of inspiration for your next creative project. Happy exploring and enhancing your AI-powered endeavors with ! AIModels.fyi Subscribe or follow me on Twitter for more content like this! Also published here

Stories, News & Mentions about LLAMA

Llama’s Stories on HackerNoon

Llama's News & Mentions