Datasets:

MarkrAI

/

AutoRAG-evaluation-2024-LLM-paper-v1

like 8

d885ba56-76b1-498a-8e6a-ec6fe78017c9

## 5.1. Apo-Rlhf The batch version of the algorithm called APO-RLHF at each round computes the score of each triplet (*x, a, a*′).2 The computation (Step 3) is very similar to Step 3 of Algorithm 1 except that here we compute the norm w.r.t V −1 Algorithm 2 APO-RLHF: Active Preference Optimization for RLHF Require: Dataset D = {(xi, ai, a′ i)}N i=1, *λ >* 0, sample budget T, encoder ϕ, batch size B, SFT policy πSFT 1: Initialize V = λI 2: **for** t = 1 . . . ⌊T/B⌋ do 3: To every triplet (*x, a, a*′) ∈ D, assign score(*x, a, a*′) = ∥ϕ(x, a) − ϕ(*x, a*′)∥V −1 4: E = Top B items from D by score. 5: for (x, a, a′) *∈ E* do 6: Observe feedback y. Let z = ϕ(x, a) − ϕ(*x, a*′) 7: Update V ← V + zz⊺ 8: end for 9: Update ˆθ ← GRADIENT-STEP(ˆθ, E, {yi}B i=1) 10: end for 11: Policy πT ← PPO(πSFT, ˆθ) instead of H(ˆθ)−1. A close look at the proof of Theorem 4.2 (see Appendix A) will reveal that changing the matrix does not alter the theoretical guarantees. We do this here because it is computationally more efficient to update V compared to H(θ). Moreover, data is now collected in batches and those triplets are queried in a batch that have the highest score to maximize exploration. At the end of every batch, we update the parameter ˆθ via GRADIENT-STEP which is a blackbox gradient based optimization algorithm that performs gradient steps of ˆ

290b4dbd-46b4-452a-99f6-71052fd15fd7

## 5.1. Apo-Rlhf H(ˆθ)−1. A close look at the proof of Theorem 4.2 (see Appendix A) will reveal that changing the matrix does not alter the theoretical guarantees. We do this here because it is computationally more efficient to update V compared to H(θ). Moreover, data is now collected in batches and those triplets are queried in a batch that have the highest score to maximize exploration. At the end of every batch, we update the parameter ˆθ via GRADIENT-STEP which is a blackbox gradient based optimization algorithm that performs gradient steps of ˆθ by minimizing the log-loss (2) over the dataset specified by E and {yi}B i=1. Finally, the aligned policy πT is learned via PPO which inputs the SFT policy πSFT and the learnt reward model ˆθ and aligns πSFT via PPO (Schulman et al., 2017).

ee46a063-84fd-475b-81f1-fdbbce160dd2

## 5.2. Controlled Sentiment Generation Experiment Design & Evaluation: In our experiment on controlled sentiment generation, we consider a user group that prefers positive sentiment completions for a prompt. Using the IMDb dataset as a basis for our inputs (Maas et al., 2011), the goal for the optimal policy is to produce responses y that exhibit positive sentiment, catering to the user group's preferences for a given prompt x. For a controlled evaluation, we generated a set of preference pairs utilizing a pre-trained sentiment classifier where p(positive | x, yw) *> p*(positive | *x, y*l) for the evaluation. We implement the 3 phases of RLHF pipeline ((Christiano et al., 2017; Ouyang et al., 2022)) - 1. Supervised Fine-tuning 2. Reward Modelling Phase 3. RL Fine-tuning with PPO. For the SFT policy, we fine-tune GPT-2 (Radford et al., 2019) until convergence on reviews from the train split of the IMDb dataset and use this GPT- 2 backbone for both the reward model and PPO (Schulman et al., 2017) training. The generations are evaluated against the ground truth reward r∗ for positive sentiment, provided by the pre-trained sentiment classifier (similar to (Rafailov et al., 2023)). To demonstrate the performance of APO-RLHF (algorithm 2) against random selection baselines, we use the feature representation ϕ(*x, y*) given a prompt x and response y using the GPT-2 SFT backbone. We estimate the score bt(*x, y*chosen, yrejected) for each (*x, y*chosen, yrejected) in our dataset D using score defined in step 3 and select the top-B samples (step 4) to update the reward model. We repeat this process K times and compare the same against random baseline (where we select the B samples randomly) for different values of BK. Note that our total sample budget is now T = BK. Finally, we train PPO (Schulman et al., 2017) with the learned reward model and evaluate the responses against the ground truth reward r∗ for positive sentiment. Figure 2 shows the results of the experiment. It is clear that evaluation accuracy of the reward model learned by APO-RLHF is much higher than the one learned via random selection baseline

3b7c64ef-c828-4529-970c-0a58c46d3355

## 5.2. Controlled Sentiment Generation -B samples (step 4) to update the reward model. We repeat this process K times and compare the same against random baseline (where we select the B samples randomly) for different values of BK. Note that our total sample budget is now T = BK. Finally, we train PPO (Schulman et al., 2017) with the learned reward model and evaluate the responses against the ground truth reward r∗ for positive sentiment. Figure 2 shows the results of the experiment. It is clear that evaluation accuracy of the reward model learned by APO-RLHF is much higher than the one learned via random selection baseline even when APO-RLHF's sample budget is only 5% of the data and random baseline's 40% illustrating the suboptimality gap as shown in Theorem 3.2. Next, we compare the performance of the aligned models trained via PPO using the respective reward models. For APO-RLHF, we use the reward model trained on a sample budget of 10% while for random baseline it is the highest accuracy reward model (corresponding to 40% sample). From figure 2 it is evident that APO-RLHF outperforms the random baseline by a 60-40 win rate demonstrating the efficiency of our Active Preference Optimization procedure.

6a9c0ba6-5659-4f7b-be96-be6ed6379dfd

## 6. Generalization To Function Approximation In this section, we remove the assumption of BTL preference model characterized by a linear parameter θ. Instead, we assume that we have access to a function class F ={f : *X×A×A →* [0, 1] : f(x, a, a′)+f(x, a′, a)=1}, where f(*x, a, a*′) denotes the probability that the arm a wins over arm a′ given context x when the preference function is f, i.e., f(*x, a, a*′) = P[a ≽ a′|*x, f*] where a ≽ a′ denotes the event that a wins over a′. Now, we assume that there is a true f ∗ ∈ F from which the data is generated. Further, we assume a *Condorcet* winner at each context: Assumption 6.1. For all context x∈X, there is an action a∗(x)∈A(x) such that f ∗(x, a∗(x), a0)≥ 1/2 ∀a0 ∈A(x). Note that in this case, there is no direct reward model and is therefore a generalization of the BTL model. The absence of a reward model makes the problem more nuanced. Accordingly, the simple regret is now defined as: $R(T)=\max_{x\in\mathcal{X}}\max_{a\in\mathcal{A}(x)}f^{*}(x,a,\pi_{T}(x))-1/2$ Note that f ∗(x, a∗(x), πT (x)) ≥ 1/2 by assumption 6.1, thus R(T) is always non-negative.

5ee4cc02-a095-472c-9180-f1e556872f67

## 6.1. Algorithm Our algorithm takes a function class F and a confidence level δ ∈ (0, 1] as its inputs. First, a regularized least square estimate of f ∗ is computed by minimizing the cumulative squared prediction error: $$\widehat{f}_{t}\in\arg\min_{f\in{\cal F}}\sum\nolimits^{t-1}\left(y_{s}-f(x_{s},a_{s},a^{\prime}_{s})\right)^{2}.\tag{9}$$ The confidence set ${\cal C}_{t}({\cal F},\delta)$ is then defined as the set of all functions $f\in{\cal F}$ satisfying $$\sum\nolimits^{t-1}_{s=1}(f(x_{s},a_{s},a^{\prime}_{s})-\widehat{f}_{t}(x_{s},a_{s},a^{\prime}_{s}))^{2}\leq\beta_{t}({\cal F},\delta)\,\tag{10}$$ where βt(F, δ) is an appropriately chosen confidence pa- rameter. Since yt ∼ Ber(f ∗(xt, at, a′ t)) given (xt, at, a′ t), We have Var[yt] ≤ 1/4. Thus, following (Ayoub et al., 2020), we set the confidence parameter $$\beta_{t}({\mathcal{F}},\delta)\!=\!2\log\frac{2{\mathcal{N}}({\mathcal{F}})}{\delta}\!+\!2\sqrt{\log\frac{4t(t\!+\!1)}{\delta}}\!+\!4\;,$$ where N(F) denotes the (1/t, *||·||*∞)-covering number3 of F. This choice of confidence width ensures that f ∗ lies in the confidence set Ct(F, δ) at all time instant t ≥ 1 with probability at least 1 − δ (Lemma B.1). Next, for each triple

c3879b5f-a962-4ca9-8603-99c081a05294

## 6.1. Algorithm F}})}{\delta}\!+\!2\sqrt{\log\frac{4t(t\!+\!1)}{\delta}}\!+\!4\;,$$ where N(F) denotes the (1/t, *||·||*∞)-covering number3 of F. This choice of confidence width ensures that f ∗ lies in the confidence set Ct(F, δ) at all time instant t ≥ 1 with probability at least 1 − δ (Lemma B.1). Next, for each triplet (*x, a, a*′), we define the exploration bonus bt(*x, a, a*′) at round t as bt(*x, a, a*′)= max f1,f2∈Ct(F,δ)|f1(x, a, a′)−f2(*x, a, a*′)|, (11) which measures the uncertainty of a pair of actions a, a′ given a context x with respect to the confidence set Ct(F, δ). The near-optimal action set At(x) at round t is defined as the set of all actions in the previous set At−1(x) satisfying ˆft(*x, a, a*0) + bt(x, a, a0) ≥ 1/2 ∀a0 ∈ At−1(x) . (12) Intuitively speaking, we retain only those actions from the previous near-optimal set which are not significantly outperformed by other actions according to the estimates of the current round. Since f ∗ ∈ Ct(F, δ), the optimal action a∗(x) lies in At(x) for each context x for all t with high probability (Lemma B.2). By pruning out suboptimal actions every round, we make better use of samples. When the set At(x) becomes a singleton (i.e., a∗(x) has been identified w.h.p), we remove this context from the pool of contexts considered in future rounds. To encourage exploration, we choose actions (at(x), a′ t(x)) which has the highest uncertainty in At(x), i.e., we choose

37f159c4-bd4d-4f63-932e-5eea88e52d7b

## 6.1. Algorithm ) lies in At(x) for each context x for all t with high probability (Lemma B.2). By pruning out suboptimal actions every round, we make better use of samples. When the set At(x) becomes a singleton (i.e., a∗(x) has been identified w.h.p), we remove this context from the pool of contexts considered in future rounds. To encourage exploration, we choose actions (at(x), a′ t(x)) which has the highest uncertainty in At(x), i.e., we choose (at(x), a′ t(x))=argmaxa,a′∈At(x) bt(x, a, a′) . (13) Next, we choose the context xt that provides the maximum information about the unknown preference function f ∗, i.e., $$x_{t}\in\mbox{argmax}_{x\in{\cal X}}\,b_{t}(x,a_{t}(x),a^{\prime}_{t}(x)).\tag{14}$$ We play the actions at = at(xt) and a′ t = a′ t(xt) in round t and observe the preference feedback yt. We repeat this until we have exhausted the budget T. Our final policy πT samples an action uniformly at random from the set AT (x) for every context x *∈ X*. Pseudocode is given in App. B. 3For any *α >* 0, we call F α an (α, *||·||*∞) cover of the function class F if for any f *∈ F* there exists an f ′ in F α such that ||f ′ − f||∞:= supx∈X |f ′(x) − f(x)|≤ α.

2acca04c-00c0-4dbf-8c48-8e12f4be7a3e

## 6.2. Analysis We characterize the complexity of the function class F by its *eluder dimension* (Russo & Van Roy, 2013). Definition 6.2 (Eluder dimension). The ε-eluder dimension dimE(F, ε) of a function class F defined on a domain X is the length of the longest sequence {xi}n i=1 ⊆X of input points such that for some ε′ ≥ε and for each i ∈ {2*, . . . , n*}, sup f1,f2∈F j=1(f1−f2)2(xi)≤ε′ � >ε′ . ��i−1 � (f1−f2)(xi) ��� We denote by $d_{\mathcal{E}}(\mathcal{F})=\dim_{\mathcal{E}}\left(\mathcal{F},1/T\right)$, the $(1/T)$-Eluder dimension of the function class $\mathcal{F}$. Now, we state sub-optimality guarantee of the final policy using eluder dimension and metric entropy of the function class $\mathcal{F}$. **Theorem 6.3** (Suboptimality Gap).: _Let $\delta\in(0,1)$. Under assumption 6.1, the suboptimality gap $R(T)$ of our policy $\pi_{T}$ after running $\mathbb{A}\mathcal{P}\mathcal{O}-\mathcal{G}\mathcal{E}\mathcal{D}$ (algorithm 3) for $T$ steps is upper bounded with probability at least $1-\delta$ as_ $$R(T)\leq\tilde{O}\bigg{(}\sqrt{\frac{\log(\mathcal{N}(\mathcal{F})T/\delta)d_{\mathcal{E}}(\mathcal{F})}{T}}\bigg{)}.$$ Proof is deferred to Appendix B due to space constraint but essentially follows ideas similar to Theorem 4.2 with difference that we crucially leverage action elimination (Step 8). BTL model. For the BTL preference model f(*x, a, a*′) = µ

1569f1ed-06ca-4d8e-8fa7-5267daad758c

## 6.2. Analysis $$R(T)\leq\tilde{O}\bigg{(}\sqrt{\frac{\log(\mathcal{N}(\mathcal{F})T/\delta)d_{\mathcal{E}}(\mathcal{F})}{T}}\bigg{)}.$$ Proof is deferred to Appendix B due to space constraint but essentially follows ideas similar to Theorem 4.2 with difference that we crucially leverage action elimination (Step 8). BTL model. For the BTL preference model f(*x, a, a*′) = µ(ϕ(x, a)⊤θ−ϕ(*x, a*′)⊤θ). Define r = *h/h*, where h = supx,a,a′,θ ˙µ(ϕ(x, a)⊤θ−ϕ(x, a′)⊤θ) , h = infx,a,a′,θ ˙µ(ϕ(x, a)⊤θ−ϕ(x, a′)⊤θ) . Then the log N(F) and Eluder dimension of F are at most O(d log(hT)) and O(dr2h log(rShT)), respectively. Note that h = 1/κ and h ≤ 1/4. This yields log N(F) = O(d log T) and dE(F) = O(κ2d log T). Substituting this in Theorem 6.3, we get the sub-optimality gap O(κd/ √ T), which is √κ factor loose than Theorem 4.2. This is because we crucially use self-concordance of the sigmoid function in Theorem 4.2 to shave this extra √κ factor. Nevertheless, Theorem 6.3 is general enough to subsume other preference models (e.g. probit/Thurstone) beyond the BTL model. Conclusion. In this work we aimed to answer the question whether the simple approach of sampling prompts uniformly from a dataset to solicit feedback is sample efficient. We showed that this method can suffer constant suboptim

496358ae-d383-433f-a9eb-003721c573e9

## 6.2. Analysis κ factor loose than Theorem 4.2. This is because we crucially use self-concordance of the sigmoid function in Theorem 4.2 to shave this extra √κ factor. Nevertheless, Theorem 6.3 is general enough to subsume other preference models (e.g. probit/Thurstone) beyond the BTL model. Conclusion. In this work we aimed to answer the question whether the simple approach of sampling prompts uniformly from a dataset to solicit feedback is sample efficient. We showed that this method can suffer constant suboptimality gap when used for model alignment. Then we proposed APO which actively samples contexts (prompts) to achieve O(1/ √ T) suboptimality scaling with number of samples T. We believe that our algorithm recipe is general enough to be extended to other alignment methods like Direct Preference Optimization (Rafailov et al., 2023). This is a promising fu- ture direction of our work towards building sample-efficient algorithms for LLM alignment.

a11231cd-0cb5-4ec0-9476-a0a6d283a52e

## Broader Impact This paper presents work whose goal is to advance the field of Machine Learning. There are many potential societal consequences of our work, none which we feel must be specifically highlighted here.

07307cb8-e69f-4b74-a19d-c0c9e289b12f

## A. Missing Proofs From Section 4 First we state the result from logistic bandit literature that characterizes the confidence set for the constrained maximum likelihood estimator. Here we give one version of the confidence set from (Lee et al., 2023) but note that similar guarantees are also derived in (Abeille et al., 2021). Lemma A.1 (Confidence Set for MLE (Theorem 1 of (Lee et al., 2023)). Let ˆθt be the constrained maximum likelihood estimator after t − 1 time steps defined as follows: $$\hat{\theta}_{t}=\operatorname*{argmin}_{\theta\in\Theta}-\sum_{s=1}^{t-1}y_{s}\log(\mu(z_{s}^{\intercal}\theta))+(1-y_{s})\log(1-\mu(z_{s}^{\intercal}\theta))$$ _Now define the set_ $$\mathcal{C}_{t}(\delta)=\{\theta\in\Theta:\mathcal{L}_{t}(\theta)-\mathcal{L}_{t}(\hat{\theta})\leq\beta_{t}(\delta)^{2}\}$$ where βt(δ) = � 10d log � St $\frac{St}{4d}+e)+2(e-2+S)\log\left(\frac{1}{\delta}\right)$. Then we have $P(\forall t\geq1,\theta^{*}\in\mathcal{C}_{t}(\delta))\geq1-\delta$._ be found in section 3.1 of (I see et al., 2023). Next we present another lemma that The details of the proof can be found in section 3.1 of (Lee et al., 2023). Next we present another lemma that quantifies the parameter estimation error. Using this lemma and a novel self-concordance property, we will prove A.3. Lemma A.2 (Lemma 6 of (Lee et al., 2023)). Let ˆθt be defined above

19bf6673-113e-4413-9ee8-31d3a16e046c

## A. Missing Proofs From Section 4 \delta$._ be found in section 3.1 of (I see et al., 2023). Next we present another lemma that The details of the proof can be found in section 3.1 of (Lee et al., 2023). Next we present another lemma that quantifies the parameter estimation error. Using this lemma and a novel self-concordance property, we will prove A.3. Lemma A.2 (Lemma 6 of (Lee et al., 2023)). Let ˆθt be defined above. Further, let θ∗ ∈ Ct(δ). Then, $||\hat{\theta}_{t}-\theta^{*}||^{2}_{H_{t}(\theta^{*})}\leq\gamma_{t}(\delta)^{2}:=2(2+2S)f(d,S,t,\delta)$ where $$f(d,S,t,\delta):=2(e-2)(2+2S)d\log(\frac{5St}{d})+2(e-2)(2+2S)\log(\frac{t}{\delta})+\frac{5d}{4}+\frac{d^{2}}{16St}$$ _Simplifying, $\gamma_{t}(\delta)^{2}=CS^{2}\left(d\log\frac{St}{d}+\log\frac{t}{\delta}\right)$ for some $C>0$._ The proof of the lemma can be four **penix C.4.4** of (L. The proof of the lemma can be found in appendix C.4.4 of (Lee et al., 2023). Now we are ready to present the proof of lemma A.3. Lemma A.3. Suppose θ∗ ∈ Ct(δ). Then, ∥θ∗ − ˆθ∥Ht(ˆθt) ≤ CS 1/2γt(δ). Proof. By Taylor's theorem, we have, v=0 (1

64dcaa95-973a-43d4-9094-ae76ca82dc4f

## A. Missing Proofs From Section 4 ** of (L. The proof of the lemma can be found in appendix C.4.4 of (Lee et al., 2023). Now we are ready to present the proof of lemma A.3. Lemma A.3. Suppose θ∗ ∈ Ct(δ). Then, ∥θ∗ − ˆθ∥Ht(ˆθt) ≤ CS 1/2γt(δ). Proof. By Taylor's theorem, we have, v=0 (1 − v)(ˆθ − θ∗)⊺∇2Lt(θ∗)(ˆθ − θ∗)dv Lt(ˆθt) *− L*t(θ∗) = ∇Lt(θ∗)⊺(ˆθt − θ∗) + � 1 = ∇Lt(θ∗)⊺(ˆθt − θ∗) + s=1 v=0 (1 − v) ˙µ(z⊺ s θ∗ + v(z⊺ s ˆθt − z⊺ s θ∗))dv � (z⊺ s (ˆθt − θ∗))2 �� 1 t−1 � = ∇Lt(θ∗)⊺(ˆθt − θ∗) + ∥ˆθt − θ∗∥2 ˜ Gt(θ∗,ˆθt) − λ∥ˆθt − θ∗∥2 where we define ˜Gt(θ∗, ˆθt) = λId + �t−1 s=1 �� 1 v=0(1 − v) ˙µ(z⊺ s θ∗ + v(z⊺ s ˆθt − z⊺ s θ∗))dv � zsz⊺ s . Thus, we obtain, ∥ˆθt − θ∗∥2 ˜ Gt

b7bd0d5c-1b01-4fd6-b1f1-36507d9408e3

## A. Missing Proofs From Section 4 �t − θ∗∥2 where we define ˜Gt(θ∗, ˆθt) = λId + �t−1 s=1 �� 1 v=0(1 − v) ˙µ(z⊺ s θ∗ + v(z⊺ s ˆθt − z⊺ s θ∗))dv � zsz⊺ s . Thus, we obtain, ∥ˆθt − θ∗∥2 ˜ Gt(θ∗,ˆθt) = Lt(θ∗) *− L*t(ˆθt) + ∇Lt(θ∗)⊺(ˆθt − θ∗) + λ∥ˆθt − θ∗∥2 Now, from a novel self-concordant analysis (see lemma C.1), Ht(ˆθt) ≼ C(2 + 2S)2 ˜Gt(θ∗, ˆθt) for some *C >* 1.01. Thus, ∥ˆθt − θ∗∥2 Ht(ˆθt) ≤ C(2 + 2S)2∥ˆθt − θ∗∥2 ˜ Gt(θ∗,ˆθt) = C(2 + 2S)2 � Lt(θ∗) *− L*t(ˆθt) + ∇Lt(θ∗)⊺(ˆθt − θ∗) + λ∥ˆθt − θ∗∥2� ≤ C(2 + 2S)2 � 4λS2 + βt(δ)2 + ∇Lt(θ∗)⊺(ˆθt − θ∗) � (15) where the last inequality is because (a) ˆθt, θ∗ ∈ Θ which implies that ∥θ∗ − ˆθt∥ ≤ diam(Θ)

449de063-87e5-4761-a617-a110baa048f1

## A. Missing Proofs From Section 4 θt − θ∗) + λ∥ˆθt − θ∗∥2� ≤ C(2 + 2S)2 � 4λS2 + βt(δ)2 + ∇Lt(θ∗)⊺(ˆθt − θ∗) � (15) where the last inequality is because (a) ˆθt, θ∗ ∈ Θ which implies that ∥θ∗ − ˆθt∥ ≤ diam(Θ) = 2S and (b) by lemma A.1, Lt(θ∗) *− L*t(ˆθt) ≤ βt(δ)2 since θ∗ ∈ Ct(δ) by assumption. Thereafter, from the proof of Lemma 6 of (Lee et al., 2023) it can be extracted that |∇Lt(θ∗)⊺(ˆθt − θ∗)| ≤ ∥ˆθt−θ∗∥2 Ht(θ∗) 2(2+2S) + f(*d, S, t, δ*) . Then using lemma A.2, the R.H.S of 15 can be bounded by 2f(*d, S, t, δ*). Thus, we now obtain, ∥ˆθt − θ∗∥2 Ht(ˆθt) ≤ C(2 + 2S)2 � 4λS2 + βt(δ)2 + 2f(*d, S, t, δ*) � 4S2(2+2S)2 ) (2 + 2S)2 + βt(δ)2 + γt(δ)2 2(2 + 2S) ≤ C(2 + 2S)2 � 1 � (Setting λ = 1 2(2 + 2S) �2 ≤ C(2 + 2S)2 � 1 (2 + 2S) + βt(δ) + γt(δ) � 2(2 + 2S) � � 1 =⇒ ∥ˆθt − �

9285946b-13ad-4c06-b61f-63a8ade0f26a

## A. Missing Proofs From Section 4 �*) � 4S2(2+2S)2 ) (2 + 2S)2 + βt(δ)2 + γt(δ)2 2(2 + 2S) ≤ C(2 + 2S)2 � 1 � (Setting λ = 1 2(2 + 2S) �2 ≤ C(2 + 2S)2 � 1 (2 + 2S) + βt(δ) + γt(δ) � 2(2 + 2S) � � 1 =⇒ ∥ˆθt − θ∗∥Ht(ˆθt) ≤ C(2 + 2S) (2 + 2S) + βt(δ) + γt(δ) � = C(1 + (2 + 2S)βt(δ) + √ d ) + log( t 2 + 2Sγt(δ)) = CS3/2 �� d log(St δ ) � Theorem A.4 (Suboptimality Upper Bound). Let δ ∈ (0, 1). The suboptimality of the policy πT specified at the end of APO (algorithm 1) after running the algorithm for T rounds is upper bounded with probability at least 1 − δ as follows: d ) + log(T T δ ) � log � 1 + T λκd � κd R(T) ≤ CS3/2 �� d log(ST Proof. Let the suboptimality gap for a context x *∈ X* be denoted as R(*T, x*). Thus, R(*T, x*) = (ϕ(x, a∗(x)) − ϕ(*x, π*T (x)))⊺ θ∗ (1) ≤ (ϕ(x, a∗(x)) − ϕ(*x, π*T (x)))⊺ θ∗ + (ϕ(x, πT (x)) − ϕ(*x, a*∗(x)))⊺ � 1 T � t=1 ˆθt T � T = (ϕ(x, a∗(x)) − ϕ(*x, π*T (x)))

8e6c21c5-6f21-49c7-b2e9-c4b68e87116e

## A. Missing Proofs From Section 4 )) − ϕ(*x, π*T (x)))⊺ θ∗ (1) ≤ (ϕ(x, a∗(x)) − ϕ(*x, π*T (x)))⊺ θ∗ + (ϕ(x, πT (x)) − ϕ(*x, a*∗(x)))⊺ � 1 T � t=1 ˆθt T � T = (ϕ(x, a∗(x)) − ϕ(*x, π*T (x)))⊺ (θ∗ − 1 t=1 ˆθt) T � = 1 T t=1 (ϕ(x, a∗(x)) − ϕ(*x, π*T (x)))⊺ (θ∗ − ˆθt) T � T ≤ 1 $$\sum_{i=1}^{T}\|\phi(x,a^{*}(x))-\phi(x,\pi_{T}(x))\|_{H_{i}^{-1}(\delta_{i})}\|\theta^{*}-\hat{\theta}_{i}\|_{H_{i}(\delta_{i})}$$ (Cauchy-Schwarz) Here inequality (1) is due the definition of policy $\pi_{T}(x):=\operatorname*{argmax}_{\theta\in\mathcal{A}}\phi(x,a)^{\intercal}\left(\frac{1}{T}\sum_{i=1}^{T}\hat{\theta}_{i}\right).$ Now we use lemma A.3 to upper bound $\|\theta^{*}-\hat{\theta}_{i}\|_{H_{i}(\delta_{i})}$ with $CS^{1/2}\gamma_{T}(\delta)$ which we further upper bound by $CS^{1/2}\gamma_{T}(\delta)$ after noting that $\gamma_{1}(\delta)\leq\gamma_{1}(\delta)$ for all $i\in\mathbb{R}^{n}$. The lower bound

fdf9c665-f21a-419e-89b8-0af2da9084ba

## A. Missing Proofs From Section 4 we use lemma A.3 to upper bound $\|\theta^{*}-\hat{\theta}_{i}\|_{H_{i}(\delta_{i})}$ with $CS^{1/2}\gamma_{T}(\delta)$ which we further upper bound by $CS^{1/2}\gamma_{T}(\delta)$ after noting that $\gamma_{1}(\delta)\leq\gamma_{1}(\delta)$ for all $i\in\mathbb{R}^{n}$. The lower bound is to upper bound ∥θ∗ − ˆθt∥Ht(ˆθt) with CS 1/2γt(δ) which we further upper bound by CS1/2γT (δ) after noting that γt(δ) ≤ γt+1(δ) for all t ∈ [T]. Thus, we now have, $$R(T,x)\leq\frac{CS^{1/2}\gamma_{T}(\delta)}{T}\sum_{t=1}^{T}\|\phi(x,a^{*}(x))-\phi(x,\pi_{T}(x))\|_{H_{t}^{-1}(\hat{\theta}_{t})}$$ $$\leq\frac{CS^{1/2}\gamma_{T}(\delta)}{T}\sum_{t=1}^{T}\|\phi(x_{t},a_{t})-\phi(x_{t},a_{t}^{\prime})\|_{H_{t}^{-1}(\hat{\theta}_{t})}$$ To get the above inequality, we use the fact that algorithm's choice of the triplet is (xt, at, a′ t) := argmaxx∈X,a,a′∈A∥ϕ(x, a) − ϕ(x, a′)∥H−1 t (ˆθt). Now, we are left with terms that can be bounded using Elliptic Po- tential Lemma (lemma C.2) after using the

f6af81c3-8554-466a-a85d-f44b7e8c9fbd

## A. Missing Proofs From Section 4 }(\hat{\theta}_{t})}$$ To get the above inequality, we use the fact that algorithm's choice of the triplet is (xt, at, a′ t) := argmaxx∈X,a,a′∈A∥ϕ(x, a) − ϕ(x, a′)∥H−1 t (ˆθt). Now, we are left with terms that can be bounded using Elliptic Po- tential Lemma (lemma C.2) after using the fact that ∥ϕ(xt, at) − ϕ(xt, a′ t)∥H−1 t (ˆθt) ≤ √κ∥ϕ(xt, at) − ϕ(xt, a′ t)∥V −1 t due Algorithm 3 APO-Gen: Active Preference Optimization with General Function Approximation Require: Context set X, action set A = [K], function class F, failure level δ ∈ (0, 1) 1: Set X0 = X and A0(x) = A ∀x *∈ X*, 2: **for** t = 1, 2*, . . . T* do 3: Compute function estimate ˆft usning (9). 4: Construct confidence set Ct(F, δ) using (10). 5: Intialize the Xt = Xt−1 6: for each context x *∈ X*t−1 do 7: For each pair of actions a, a′ ∈ At−1(x), compute the bonus bt(*x, a, a*′) using (11). 8: Find the near-optimal action set At(x) using (12) 9: if |At(x)| = 1 then 10: Set AT (x) = At(x) 11: Xt ← Xt \ {x} 12: end if 13: end for 14: Choose context and pair of actions (xt, at, a′ t) = argmaxx∈Xt,a,a′∈At(x) bt

847d8da9-0924-44f2-b88c-ba282e84ba48

## A. Missing Proofs From Section 4 t(*x, a, a*′) using (11). 8: Find the near-optimal action set At(x) using (12) 9: if |At(x)| = 1 then 10: Set AT (x) = At(x) 11: Xt ← Xt \ {x} 12: end if 13: end for 14: Choose context and pair of actions (xt, at, a′ t) = argmaxx∈Xt,a,a′∈At(x) bt(*x, a, a*′) 15: Observe preference yt ∼ Ber(f ∗(xt, at, a′ t)) 16: end for 17: Output final policy πT (x) = a for some a *∈ A*T (x). to the fact that Vt ≼ κHt(ˆθt). Thus, κSγT (δ) T R(T, x) ≤ C √ t=1 ∥ϕ(xt, at) − ϕ(xt, a′ t)∥V −1 t T � κSγT (δ) T ≤ C √ t=1 ∥ϕ(xt, at) − ϕ(xt, a′ t)∥2 V −1 t (Cauchy-Schwarz) T � � � � �T κSγT (δ) T ≤ C √ � 2dT log � 1 + T λκd � (Lemma C.2) d ) + log(T T (Def. of γT (δ)) = CS3/2 �� d log(ST δ ) � log � 1 + T λκd � κd

990adea3-0559-4802-bfa7-96f64da0792e

## B. Missing Proofs From Section 6 First let us recall the notations. At any time t in the algorithm, we have a dataset Dt = {(xs, as, a′ s, ys)}t−1 s=1. Let the loss function be the squared error defined as Lt(f) := �t−1 s=1(ys − f(xs, as, a′ s))2. Further let ˆft be the least squares estimate: ˆft ∈ argmin f∈F Lt(f) (1/4) log (4t(t + 1)/δ) � . With these, we present the result that characterizes the confidence set around ˆft. and let βt(F, δ) = 2 log (2N (F, 1/t, ||·||∞) /δ) + 4 � 1 + � Lemma B.1 (Confidence Set for Function Approximation (Lemma A.1 of (Chen et al., 2022)). Let δ ∈ (0, 1). Define the confidence set Ct(F, δ) = {f ∈ F| s=1 (f(xs, as, a′ s) − ˆft(xs, as, a′ s))2 ≤ βt(F, δ) t−1 � Let Et(δ) be the event that f ∗ ∈ Ct(F, δ). Then, P[Et(δ)] ≥ 1 − δ. Further, P � ∩T t=1Et(δ/T) � ≥ 1 − δ. Proof. The proof is a direct extension of lemma C.3 by observing that in our case the subgaussianity parameter σ = 1/4 since our rewards are Bernoulli and by setting α = 1/t. Moreover, C = 1 in our case. Finally, since Et(δ/t) holds with probability at least 1 − δ/t, by union bound we can show that P � ∩T t=1Et(δ/T) � = 1 − P � ∪T t=1E

d398fbda-31c4-4d78-8961-ce88eda09858

## B. Missing Proofs From Section 6 Proof. The proof is a direct extension of lemma C.3 by observing that in our case the subgaussianity parameter σ = 1/4 since our rewards are Bernoulli and by setting α = 1/t. Moreover, C = 1 in our case. Finally, since Et(δ/t) holds with probability at least 1 − δ/t, by union bound we can show that P � ∩T t=1Et(δ/T) � = 1 − P � ∪T t=1Et(δ/T) � ≥ 1 − �T t=1 P[Et(δ/T)] ≥ 1 − δ. Hereon, we assume that for all t ∈ [T], Et(δ/T) holds. All subsequent guarantees are under this event. Now for a given tuple (x, a, a′) ∈ X × A × A, for a given δ ∈ (0, 1), define bt(x, a, a′) = maxf,f ′∈Ft(δ)|f(x, a, a′) − f ′(x, a, a′)|. We have the following lemma. Lemma B.2. For a given context x ∈ X, let {As(x)}t s=0 be defined as follows: (a) A0(x) = A and (b) As(x) = {a ∈ As−1(x)| ˆfs(x, a, a′) + bs(x, a, a′) ≥ 1 2 ∀a′ ∈ As−1(x)}. Then, we have, a∗(x) ∈ As(x). Proof. The proof is by induction. First note that by definition of a∗(x), f ∗(x, a∗(x), a′) ≥ 1/2 for every a′ ∈ A, and a∗(x) ∈ A0(x) = A. Suppose, for some s > 0, a∗(x) ∈ As−1(x). Now, we know that under event

77f0fb2e-cead-47b1-8e57-e57fd76c919d

## B. Missing Proofs From Section 6 2 ∀a′ ∈ As−1(x)}. Then, we have, a∗(x) ∈ As(x). Proof. The proof is by induction. First note that by definition of a∗(x), f ∗(x, a∗(x), a′) ≥ 1/2 for every a′ ∈ A, and a∗(x) ∈ A0(x) = A. Suppose, for some s > 0, a∗(x) ∈ As−1(x). Now, we know that under event Es(δ/T), f ∗ ∈ Cs(F, δ/T) and thus from definition of bs(x, a, a′), f ∗(x, a, a′) − ˆfs(x, a, a′) ≤ bs(x, a, a′). Thus, for any a′ ∈ As−1(x), 1 2 ≤ f ∗(x, a∗(x), a′) ≤ ˆfs(x, a∗(x), a′) + bs(x, a∗(x), a′) Hence a∗(x) ∈ As(x). Thus by induction, a∗(x) ∈ As(x) for all s ∈ [t]. **Theorem B.3** (Suboptimality Upper Bound for Function Approximation).: _The suboptimality of algorithm 3 is upper-bounded with probability at least $1-\delta$, as_ $$R(T)\leq\hat{O}\left(\sqrt{\frac{\log(N(\mathcal{F})T/\delta)d_{\mathcal{E}}(\mathcal{F})}{T}}\right)$$ Proof. The idea is to show that our arm elimination technique throws away arms with large suboptimality gap in every round for every context. Thus the set At(x) maintains a candidate set of good arms at every time instant. In the end, playing any action from AT (x) ensures that we only play actions from a set of actions that are only 1/ √ T suboptimal. Formally, for any context x *∈ X

ad4f0303-9530-4376-abfa-895d920f35a2

## B. Missing Proofs From Section 6 mathcal{F})T/\delta)d_{\mathcal{E}}(\mathcal{F})}{T}}\right)$$ Proof. The idea is to show that our arm elimination technique throws away arms with large suboptimality gap in every round for every context. Thus the set At(x) maintains a candidate set of good arms at every time instant. In the end, playing any action from AT (x) ensures that we only play actions from a set of actions that are only 1/ √ T suboptimal. Formally, for any context x *∈ X*, the suboptimality R(*T, x*) is upper bounded as follows: 2 R(*T, x*) = f ∗(x, a∗(x), πT (x)) − 1 T 2 ≤ 1 t=1 � ˆft(x, a∗(x), πT (x)) + bt(x, a∗(x), πT (x)) − 1 � (a∗(x), πT (x) *∈ A*t(x) ∀ t ∈ [T]) T � = 1 T t=1 �1 2 − ˆft(x, πT (x), a∗(x)) + bt(x, a∗(x), πT (x)) � (f(*x, a, a*′) + f(x, a′, a) = 1 ∀ f *∈ F*) T � = 1 T t=1 �1 2 − ˆft(x, πT (x), a∗(x)) + bt(x, πT (x), a∗(x)) � (bt(*x, a, a*′) = bt(x, a′, a)) T � T ≤ 1 t=1 [bt(x, πT (x), a∗(x)) + bt(x, πT (x), a∗(x))] (Since πT (x), a∗(x) *∈ A*t(x), line 7 Algorithm 3) T � = 2 T t=1 bt(x, πT (x), a∗(x)) $$\sum_{t=1

3d40c995-394e-4a29-91d8-8ae232777367

## B. Missing Proofs From Section 6 � (bt(*x, a, a*′) = bt(x, a′, a)) T � T ≤ 1 t=1 [bt(x, πT (x), a∗(x)) + bt(x, πT (x), a∗(x))] (Since πT (x), a∗(x) *∈ A*t(x), line 7 Algorithm 3) T � = 2 T t=1 bt(x, πT (x), a∗(x)) $$\sum_{t=1}^{T}$$ $$\leq\frac{2}{T}\,\sum_{t=1}^{T}b_{t}(x_{t},a_{t},a_{t}^{\prime})$$ (Line 9 of Algorithm 3) Now we invoke lemma C.4 to bound the RHS. $$R(T,x)\leq\frac{2}{T}\,\sum_{t=1}^{T}b_{t}(x_{t},a_{t},a_{t}^{\prime})\leq\frac{2}{T}\left[\frac{1}{T}+\min\{d_{\mathcal{E}}(\mathcal{F}),T\}+2\beta_{T}(\mathcal{F},\delta/T)\sqrt{d_{\mathcal{E}}(\mathcal{F})T}\right]$$ dE(F) Simplifying constants and using the fact that min{a, b} ≤ √ Simplifying constants and using the fact that $\min\{a,b\}\leq\sqrt{ab}$ for $a,b>0$, $R(T,x)\leq C\beta_{T}(\mathcal{F},\delta/T)\sqrt{\frac{d_{c}(\mathcal{F})}{T}}$. Using order notation, we have for all $x\in\mathcal{X}$ with probability at least $1-\delta$, $$R(T,x)\leq\tilde{O}\left(\sqrt{\frac{\log(\mathcal{N}(\mathcal{F})

1220cb0c-b4e9-4bee-b5dc-bf9dcb09d8a2

## B. Missing Proofs From Section 6 sqrt{ab}$ for $a,b>0$, $R(T,x)\leq C\beta_{T}(\mathcal{F},\delta/T)\sqrt{\frac{d_{c}(\mathcal{F})}{T}}$. Using order notation, we have for all $x\in\mathcal{X}$ with probability at least $1-\delta$, $$R(T,x)\leq\tilde{O}\left(\sqrt{\frac{\log(\mathcal{N}(\mathcal{F})T/\delta)d_{c}(\mathcal{F})}{T}}\right)$$

c289dbdc-f8c6-455f-b835-41378bab434a

## C. Some Useful Results Lemma C.1. Let z, z′ ∈ R and ˜α(*z, z*′) := � 1 0 (1 − v) ˙µ(z + v(z′ − z))dv. Then, for some C > 1 (1.01 suffices), ˜α(z, z′) ≥ ˙µ(z′) C(2 + |z − z′|)2 0 v ˙µ(z′ + v(z − z′))dv Proof. Firstly, note that by property of definite integrals � b a f(x)dx = � b a f(a + b − x)dx, we have � 1 0 (1 − v) ˙µ(z + v(z′ − z))dv = � 1 0 v ˙µ(z′) exp(−va)dv Now, we use the fact that ˙µ(x) ≥ ˙µ(y) exp(−|x − y|) (see appendix A of (Faury et al., 2022)). Let a = |z − z′|. Thus, � 1 0 v ˙µ(z′ + v(z − z′))dv ≥ � 1 0 v exp(−va)dv = ˙µ(z′) � 1 a2 = ˙µ(z′) �1 − (1 + a)e−a � a2 a ∀a > 0) $$\geq\hat{\mu}(z^{\prime})\left(\frac{1-1}{a^{\prime2}}\right)\qquad\qquad\qquad\qquad((1+a)e^{-a}<\frac{1}{a}$$ $$=\hat{\mu}(z^{\prime})\left(\frac{a-1}{a^{\prime2}}\right)$$ Again, from appendix A of (Fury et al., 2022), we have that $\hat{\alpha}(z,z^{\prime})\geq\hat{\mu}(z)/(2+a)$ which can again be lower bounded with $\hat{\

87d7c05f-625a-4e95-946e-e295b4787012

## C. Some Useful Results prime2}}\right)\qquad\qquad\qquad\qquad((1+a)e^{-a}<\frac{1}{a}$$ $$=\hat{\mu}(z^{\prime})\left(\frac{a-1}{a^{\prime2}}\right)$$ Again, from appendix A of (Fury et al., 2022), we have that $\hat{\alpha}(z,z^{\prime})\geq\hat{\mu}(z)/(2+a)$ which can again be lower bounded with $\hat{\mu}(z^{\prime})e^{-a}/(2+a)$. Combining this lower bound with above, we get, $$\hat{\alpha}(z,z^{\prime})\geq\max\left\{\frac{e^{-a}}{2+a^{\prime}},\frac{a-1}{a^{\prime2}}\right\}\hat{\mu}(z^{\prime})$$ Finally, we can lower bound the RHS with ˙µ(z′) C(2+a)2 for some *C >* 1.01. To do this, let f(x) = (2 + x)e−x. Thus, f ′(x) = −(1 + x)e−x which implies that f(x) is decreasing for *x >* 0. Thus, f(x) = 1 C is satisfied for only one value of x since f(0) = 2 > 1/C. For C = 1.01, this value is x0 = 1.1608. Then, for 0 ≤ x ≤ x0, e−x/(2 + x) ≥ 1/C(2 + x)2. Again, let g(x) = (x − 1)(x + 2)2/x3. Simplifying, we have, g(x) = 1 + 3 x − 4 x3 . It is easy to see that for x ≥ 2/ √ 3, 3 x ≥ 4 x3 which implies that g(x) ≥ 1 for all x ≥ x1 = 2/ √ 3 = 1.1547. So, for x ≥ 1

ca3b6cfe-ea13-4da7-8da8-d5077cb15ee7

## C. Some Useful Results ) ≥ 1/C(2 + x)2. Again, let g(x) = (x − 1)(x + 2)2/x3. Simplifying, we have, g(x) = 1 + 3 x − 4 x3 . It is easy to see that for x ≥ 2/ √ 3, 3 x ≥ 4 x3 which implies that g(x) ≥ 1 for all x ≥ x1 = 2/ √ 3 = 1.1547. So, for x ≥ 1.1547, g(x) ≥ 1/C (since *C >* 1) which is equivalent to (x−1) x3 ≥ 1 C(x+2)2 . The numeric solution to g(x) = 1/C for C = 1.01 is x2 = 1.1525. It can be checked via first derivative test that g(x) is increasing in x2 ≤ x ≤ x1. Thus, indeed, g(x) ≥ 1/C for all x ≥ x2. Jence, we have established so far that for C = 1.01, $${\frac{x-1}{x^{3}}}\geq{\frac{1}{C(x+2)^{2}}}\qquad\forall\,x\geq x_{2}=1.1525$$ C(2+a)2 for all a ≥ 0 which completes the proof. Since, x2 ≤ x0, we have the required result that max � e−a 2+a, a−1 a2 � ˙µ(z′) ≥ ˙µ(z′) **Lemma C.2** (Elliptic Potential Lemma).: _Let $\{z_{i}\}_{i=1}^{t}$ be a sequence of vectors in $\mathbb{R}^{d}$ such that $\|z_{i}\|\leq L$ for any $s\in[t]$. Let $V_{t}=\sum_{s=1}^{t-1}z_{i\star}z_{i}^{T}+\lambda t$. Then,_

6996bcf1-fcd6-4372-be4b-289e81baed7a

## C. Some Useful Results �µ(z′) **Lemma C.2** (Elliptic Potential Lemma).: _Let $\{z_{i}\}_{i=1}^{t}$ be a sequence of vectors in $\mathbb{R}^{d}$ such that $\|z_{i}\|\leq L$ for any $s\in[t]$. Let $V_{t}=\sum_{s=1}^{t-1}z_{i\star}z_{i}^{T}+\lambda t$. Then,_ $$\sum_{s=1}^{t}\|z_{i}\|_{V_{t-1}}^{2}\leq2d\log\left(1+\frac{tL^{2}}{\lambda t}\right)$$ . Now we present the confidence set properties of function approximation. We use the same notations as (Ayoub et al., 2020) Let (Xp, Yp)p≥1 be a sequence of random elements, Xp ∈ X for some measurable set X and Yp ∈ R. Let F be a subset of the set of real-valued measurable functions with domain X. Let F = (Fp)p≥0 be a filtration such that for all p ≥ 1, (X1, Y1, . . . , Xp−1, Yp−1, Xp) is Fp−1 measurable and such that there exists some function f ∗ ∈ F such that E[Yp | Fp−1] = f ∗(Xp) holds for all p ≥ 1. The (nonlinear) least-squares predictor given (X1, Y1, . . . , Xt, Yt) is ˆft = argminf∈F �t p=1(f(Xp) − Yp)2. We say that Z is conditionally ρ-subgaussian given the σ-algebra F if for all λ ∈ R, log E[exp(λZ) | F] ≥ 1 2λ2ρ2. For α > 0, let Nα be the ∥·∥∞-covering number of F at scale α. That is, N

e10b7e52-44ad-438b-8102-27a2289bc304

## C. Some Useful Results , Y1, . . . , Xt, Yt) is ˆft = argminf∈F �t p=1(f(Xp) − Yp)2. We say that Z is conditionally ρ-subgaussian given the σ-algebra F if for all λ ∈ R, log E[exp(λZ) | F] ≥ 1 2λ2ρ2. For α > 0, let Nα be the ∥·∥∞-covering number of F at scale α. That is, Nα is the smallest integer for which there exist G ⊂ F with Nα elements such that for any f ∈ F, ming∈G∥f − g∥∞ ≤ α. For β > 0, define Ft(β) = {f ∈ F : �t s=1(f(Xs) − ˆft(Xp))2 ≤ β}. Lemma C.3 (Theorem 5 of (Ayoub et al., 2020)). Let F be the filtration defined above and assume that the functions in F are bounded by the positive constant C > 0. Assume that for each s ≥ 1, (Yp − f ∗(Xp))p is conditionally σ-subgaussian given Fp−1. Then, for any α > 0, with probability 1 − δ, for all t ≥ 1, f ∗ ∈ Ft(βt(δ, α)), where σ2 log(4t(t + 1)/δ) � . βt(*δ, α*) = 8σ2 log(2Nα/δ) + 4tα � C + � Lemma C.4 (Lemma 2 of (Russo & Van Roy, 2013)). Let F ∈ B∞(X, C) be a set of functions bounded by *C >* 0, (Ft)t≥1 and (xt)t≥1 be sequences such that Ft ⊂ F and xt ∈ X hold for t ≥ 1. Let F |x1:t= {(f(x1)*, . . . , f*(xt)) : f *∈ F}*(⊂ Rt)

edbaf79b-88a6-4d76-843d-038e18e189e7

## C. Some Useful Results C + � Lemma C.4 (Lemma 2 of (Russo & Van Roy, 2013)). Let F ∈ B∞(X, C) be a set of functions bounded by *C >* 0, (Ft)t≥1 and (xt)t≥1 be sequences such that Ft ⊂ F and xt ∈ X hold for t ≥ 1. Let F |x1:t= {(f(x1)*, . . . , f*(xt)) : f *∈ F}*(⊂ Rt) and for S ⊂ Rt, let *diam*(S) = supu,v∈S∥u − v∥2 be the diameter of S. Then, for any T ≥ 1 and α > 0 it holds that dT t=1 diam(Ft |xt) ≤ α + C(d ∧ T) + 2δT √ T � where δT = max1≤t≤T diam(Ft |xt) and d = dimE(F, α) is the Eluder Dimension of F.

7303a0b3-ecf3-41cd-a8d4-6a50d64d1766

## Exploring The Adversarial Capabilities Of Large Language Models Lukas Struppek∗ German Center for Artificial Intelligence Technical University of Darmstadt Minh Hieu Le Technical University of Darmstadt DataSpark GmbH Dominik Hintersdorf German Center for Artificial Intelligence Technical University of Darmstadt Kristian Kersting Technical University of Darmstadt Centre for Cognitive Science of Darmstadt Hessian Center for AI (hessian.AI) German Center for Artificial Intelligence

b3d77536-f8e9-49e3-95ee-e41d1df228c4

## Abstract The proliferation of large language models (LLMs) has sparked widespread and general interest due to their strong language generation capabilities, offering great potential for both industry and research. While previous research delved into the security and privacy issues of LLMs, the extent to which these models can exhibit adversarial behavior remains largely unexplored. Addressing this gap, we investigate whether common publicly available LLMs have inherent capabilities to perturb text samples to fool safety measures, so-called adversarial examples resp. attacks. More specifically, we investigate whether LLMs are inherently able to craft adversarial examples out of benign samples to fool existing safe rails. Our experiments, which focus on hate speech detection, reveal that LLMs succeed in finding adversarial perturbations, effectively undermining hate speech detection systems. Our findings carry significant implications for (semi-)autonomous systems relying on LLMs, highlighting potential challenges in their interaction with existing systems and safety measures.

2efb100c-4c1a-4306-a8dc-21e1c45a8245

## 1 Introduction In recent months, Large language models (LLMs) have demonstrated remarkable proficiency across diverse tasks, ranging from text generation, translation, and web search to specialized applications like malware analysis or code development (Rozi`ere et al., 2023). While these models are commonly praised for their impressive capabilities, there is a growing concern regarding their security and privacy. Recent research has highlighted potential vulnerabilities, revealing that carefully selected prompts can bypass a model's safeguards, leading to the generation of undesirable content (Liu et al., 2024; Huang et al., 2024). Additionally, studies have shown that LLMs may inadvertently leak sensitive training data (Carlini et al., 2021; 2023), posing a significant privacy risk. In contrast to existing research, which primarily focuses on how LLMs can be exploited, our investigation takes a novel direction by exploring the extent to which these models can act as adversaries themselves. Anticipating the emerging role of Large Language Models (LLMs), for instance, as web agents that (semi-)autonomously engage with users and platforms, it is crucial to examine whether these LLM- based agents can bypass existing security mechanisms. This investigation is particularly important in addressing concerns related to the evasion of safeguards, such as hate speech detectors on social media platforms that aim to prevent the dissemination of hateful and violent content. Our study delves into the inherent capability of publicly available LLMs to craft adversarial examples, exploring their ability to deceive text classifiers through interactive engagement with the target model. Adversarial examples generally describe subtly manipulated model inputs that are hard to spot for a human observer but can fool a model into producing incorrect predictions. Although vastly explored in the computer vision domain (Szegedy et al., 2014; Madry et al., 2018; Struppek et al., 2022), adversarial examples also exist in natural language processing (Ebrahimi et al., 2018; Belinkov & Bisk, 2018). Roughly speaking, adversarial text examples are crafted through perturbation strategies, including changes applied to characters, words, or whole sentences while preserving the underlying meaning of the text. On the character level, typical strategies consist of replacement, addition, deletion, and swapping of characters. To do so, one can consider two scenarios. In the white-box scenario, the adversary has access to the internal workings of a model to, for example, compute model gradients w.r.t. the inputs. Conversely, in the black-box setting, only the model's prediction scores are

e7cf1f75-917b-42c2-a299-2ca0075442c7

## 1 Introduction ; Belinkov & Bisk, 2018). Roughly speaking, adversarial text examples are crafted through perturbation strategies, including changes applied to characters, words, or whole sentences while preserving the underlying meaning of the text. On the character level, typical strategies consist of replacement, addition, deletion, and swapping of characters. To do so, one can consider two scenarios. In the white-box scenario, the adversary has access to the internal workings of a model to, for example, compute model gradients w.r.t. the inputs. Conversely, in the black-box setting, only the model's prediction scores are observable, posing a greater challenge for executing the attack.

9b0ab4ed-18f4-4cf1-9bbe-edb475d3ab09

## 2 Crafting Adversarial Examples With Large Language Models To explore the adversarial capabilities of LLMs, we designed experiments around the attack pipeline shown in Fig. 1. Before presenting the result, let us describe the setup and evaluation metrics used. Experimental Setup. We investigate the adversarial capabilities of publicly available LLMs in concealing hate speech from detection. Our dataset consists of Twitter posts that exhibit hate speech targeting immigrants and women, sourced from (Garibo i Orts, 2019). To create a less platformspecific dataset, we exclude samples with hashtags and author tags, resulting in 643 samples classified as hate speech. Our target model is a binary classifier based on BERT, trained specifically for detecting English hate speech (Devlin et al., 2019; Aluru et al., 2020). Among the publicly available LLMs, we have chosen Mistral-7B-Instruct-v0.2 (Jiang et al., 2023), the sparse Mixture-of-Experts model Mixtral-8x7B (Jiang et al., 2024), and OpenChat 3.5 (Wang et al., 2024) for evaluation. It is noteworthy that models such as GPT-4 (OpenAI, 2023) and LLama2 (Touvron et al., 2023) refuse to generate adversarial examples in the context of hate speech due to their safety-aligned mechanisms (Ouyang et al., 2022). However, prior research indicates that bypassing these safeguards through prompt jailbreaking or model fine-tuning on a few examples can eliminate such safety measures (Wang et al., 2023). Consequently, we anticipate that these models, once their safety mechanisms are disabled, would demonstrate similar adversarial capabilities. Prompt and Optimization. We created a generic prompt for instructing LLMs on crafting adversarial examples. Please refer to Appx. A for the full prompt, which is composed of three specific parts: It starts with (1) a general definition of character-based adversarial text examples; then it follows (2) a set of instructions on how to craft such examples, e.g., only change a few characters in each step, minimize the classifier's prediction score and make the manipulations inconspicuous; and finally (3) we appended the list of the manipulated prompts from the previous steps together with their predicted hate scores. For the first iteration, we initialize the list with the original sample. We extract the generated adversarial example by a simple pattern

040c122c-506b-4d69-a9ef-1f9e21a0234f

## 2 Crafting Adversarial Examples With Large Language Models A for the full prompt, which is composed of three specific parts: It starts with (1) a general definition of character-based adversarial text examples; then it follows (2) a set of instructions on how to craft such examples, e.g., only change a few characters in each step, minimize the classifier's prediction score and make the manipulations inconspicuous; and finally (3) we appended the list of the manipulated prompts from the previous steps together with their predicted hate scores. For the first iteration, we initialize the list with the original sample. We extract the generated adversarial example by a simple pattern search and repeat the generation if no valid update is generated. We also repeated the generation if the number of changes exceeded a pre-defined threshold (*Max Change*). To avoid getting stuck, we abort the current optimization after | Model | Max Change | |----------------------------|--------------| | ↑ | | | Success Rate | | | ↓ | | | Hate Score | | | ↓ | | | Num. Updates | | | ↓ | | | Distance |

e148bffe-4c8f-44a5-b176-d4a7e7307804

## 2 Crafting Adversarial Examples With Large Language Models | | | Num. Updates | | | ↓ | | | Distance | | | ↑ | | | Distance Ratio | | | Mistral-7B-Instruct-v0.2 | | | ∞ | | | 74 | . | | ± | | | 0 | . | | ± | | | 10 | . | | ±

62bab892-a846-46f2-af53-6f22cd72197d

## 2 Crafting Adversarial Examples With Large Language Models | . | | ± | | | 10 | . | | ± | | | 45 | . | | ± | | | 14 | . | | Mistral-7B-Instruct-v0.2 | | | 10 | 69 | | ± | | | 0 | . | | ± | | | 7 | .

5dcd80a9-2c33-44b7-8b46-4370dc7db5d4

## 2 Crafting Adversarial Examples With Large Language Models | | 0 | . | | ± | | | 7 | . | | ± | | | 25 | . | | ± | | | 10 | . | | Mixtral-8x7B-Instruct-v0.1 | | | ∞ | | | 90 | . | | ± | | | 0 | . | |

023a9a04-38bb-47a6-a433-b0888132938a

## 2 Crafting Adversarial Examples With Large Language Models | 90 | . | | ± | | | 0 | . | | ± | | | 6 | . | | ± | | | 30 | . | | ± | | | 25 | . | | Mixtral-8x7B-Instruct-v0.1 | | | 10 | 76 | | ± | | | 0

2502aedc-8124-4d15-a125-0ad8616de8a9

## 2 Crafting Adversarial Examples With Large Language Models -8x7B-Instruct-v0.1 | | | 10 | 76 | | ± | | | 0 | . | | ± | | | 8 | . | | ± | | | 20 | . | | ± | | | 17 | . | | OpenChat 3.5 | | | ∞ | | | 96

96ea9b62-9d90-444e-964b-784c7f214a2c

## 2 Crafting Adversarial Examples With Large Language Models | . | | OpenChat 3.5 | | | ∞ | | | 96 | . | | ± | | | 0 | . | | ± | | | 5 | . | | ± | | | 47 | . | | ± | | | 37 | . | | OpenChat 3.5 |

d49dfc1d-4ab9-49d6-bf64-958b3f577b48

## 2 Crafting Adversarial Examples With Large Language Models | | ± | | | 37 | . | | OpenChat 3.5 | | | 10 | 45 | | ± | | | 0 | . | | ± | | | 6 | . | | ± | | | 25 | . | | ± | | | 20 | . |

7c50f06d-7f33-4076-8af2-83d6d22c4f94

## 2 Crafting Adversarial Examples With Large Language Models | | 25 | . | | ± | | | 20 | . | 25 consecutive steps without a valid sample update. The optimization process is repeated until the prediction score drops below 0.5 or a max of 50 updates is reached. We stress that the optimization process only requires black-box access to the target model, and no gradients are computed. Evaluation Metrics. We assessed the *Success Rate* of the LLMs as the proportion of manipulated samples misclassified as benign by the hate speech classifier. Additionally, we included the average output score of the hate speech detection model, also called *Hate Score*, assigned to the successfully perturbed samples and the average *Number of Updates* required. Before adding any perturbations, the samples are assigned an average *Hate Score* of 0.79 ± 0.09. To quantify the extent of alteration in successful samples, we computed the average Levenshtein *Distance* between the original samples and their manipulated versions. The Levenshtein distance, also referred to as edit distance, measures the number of single-character edits required to transform one string into another. Moreover, the *Distance Ratio* contextualizes the Levenshtein distance relative to the lengths of the strings, calculated as ratio(string1, *string*2) = 1 − � distance/ � len(*string*1) + len(*string*2) �� . Experimental Results. Our results, as summarized in Tab. 1, demonstrate the remarkable efficacy of LLMs in crafting adversarial text samples to deceive a hate speech classifier. Among the models tested, OpenChat 3.5 and Mixtral-8x7B achieved the highest success rate when queried without a restriction on the number of changes per step. However, both models tend to impose substantial changes to the input samples, as indicated by the distance

c8a5eeaa-1112-443e-9f58-1a146f74ffe6

## 2 Crafting Adversarial Examples With Large Language Models 2) = 1 − � distance/ � len(*string*1) + len(*string*2) �� . Experimental Results. Our results, as summarized in Tab. 1, demonstrate the remarkable efficacy of LLMs in crafting adversarial text samples to deceive a hate speech classifier. Among the models tested, OpenChat 3.5 and Mixtral-8x7B achieved the highest success rate when queried without a restriction on the number of changes per step. However, both models tend to impose substantial changes to the input samples, as indicated by the distance metrics. In contrast, Mistral-7B, despite achieving a lower overall success rate, preserves the original samples more closely, making its adversarial perturbations less conspicuous. Particularly, imposing a limit of 10 edits per step helps to maintain subtlety in the manipulations, with the distance ratio remaining at approximately 90%. Notably, OpenChat 3.5 with change restrictions exhibits a failure rate of more than fifty percent in crafting successful adversarial examples. Nevertheless, most samples where it succeeds are still close to the original samples. The individual distance ratios for all successfully perturbed samples are shown in Fig. 2. For each model, it shows the individual sample distance ratios arranged in ascending order. For OpenChat 3.5 and Mixtral-8x7B, a considerable proportion of the perturbed samples exhibit significant alterations compared to the initial samples. These strong changes may diverge from the typical approach of character-based adversarial examples, which aim to achieve their goal through minimal characterlevel modifications. Conversely, most samples perturbed by Mistral-7B and OpenChat 3.5 with change restrictions attain distance ratios exceeding 0.8. Limiting the number of changes per step successfully reduces the generation of samples with low distance ratios relative to the original samples. A collection of successfully perturbed samples and some common failure cases is available in Appx. B. We emphasize that these samples contain hate speech and might be perceived as offensive! Upon qualitative analysis of these samples, various perturbation strategies can be identified. Across all models, there is a tendency to perturb offensive words and segments of the inputs, though, at times, other vulnerable sentence parts are successfully identified for perturbation. For example, the models often insert or remove single characters, or replace characters with visually similar numbers or symbols, such as replacing l with 1 or !. Another prevalent strategy involves the addition of

d661a643-80a8-4fc1-846c-5a3958fab0a3

## 2 Crafting Adversarial Examples With Large Language Models original samples. A collection of successfully perturbed samples and some common failure cases is available in Appx. B. We emphasize that these samples contain hate speech and might be perceived as offensive! Upon qualitative analysis of these samples, various perturbation strategies can be identified. Across all models, there is a tendency to perturb offensive words and segments of the inputs, though, at times, other vulnerable sentence parts are successfully identified for perturbation. For example, the models often insert or remove single characters, or replace characters with visually similar numbers or symbols, such as replacing l with 1 or !. Another prevalent strategy involves the addition of special characters around offensive words. Additionally, whitespaces may be added to separate words or removed to merge them. Particularly, Mixtral-8x7B frequently adds stars * to samples, while Mistral-8B exhibits a broader range of perturbation strategies. In contrast, OpenChat 3.5 occasionally replaces entire words or rewrites whole sentences rather than focusing solely on character-level modifications. Such manipulations sometimes lead to the reversal of the sentence's original meaning, thereby mitigating its offensiveness. In summary, Mistral-7B emerges as the most dependable and successful model in crafting adversarial examples while maintaining small perturbations. However, all models investigated demonstrate a fundamental understanding and proficiency in crafting adversarial examples.

ce25e023-01f8-4ada-b56e-d2c0e2aa5c8b

## 3 Impact, Future Work, And Limitations Our study reveals that current publicly available LLMs possess the capability to manipulate samples to deceive classifier-based safety mechanisms. Provided with a brief definition of adversarial examples and a set of general editing instructions, these models consistently identify effective perturbations in the majority of cases. Whereas the crafting of adversarial examples has been extensively studied in research, with numerous perturbing strategies and algorithms proposed, LLMs offer a novel direction in adversarial machine learning. Without imposing specific attack strategies, all models investigated in our study demonstrated the ability to discover effective perturbations. The accessibility of LLMs allows adversarial individuals with limited technical knowledge to use existing LLMs to craft adversarial examples, lowering the barrier to malicious activity. Similarly, these very capabilities of LLMs facilitate the creation of bots that are capable of bypassing safety protocols autonomously. Moreover, machine learning-based safety measures may prove insufficient in constraining LLMs from generating malicious content, as these models inherently possess the capacity to identify vulnerabilities and devise strategies to evade detection systems. Hence, there is a pressing need to develop novel defense mechanisms to counteract such misuse of LLMs and potential attacks perpetrated by these models. Our insights also unveil new prospects for developing robust and reliable safety mechanisms. A common strategy to enhance the robustness of detection models against adversarial perturbations is to incorporate adversarial examples during the training phase, a technique commonly referred to as adversarial training (Goodfellow et al., 2015). While crafting adversarial perturbations in the vision domain is relatively straightforward using gradient-based methods, implementing adversarial training in the text domain is more complex and depends upon the chosen perturbation strategy. Leveraging LLMs might provide a powerful approach for crafting adversarial examples by exploiting a diverse range of potential perturbation strategies that need not be manually defined and can dynamically adjust to the current training state of a model. While our research focuses on unveiling the general adversarial capabilities of LLMs, we recognize that there is much more to explore. To achieve a more comprehensive understanding, it is essential to examine additional systems, domains, and target models. Moreover, we believe that there is room for improvement in optimizing the model prompt and optimization strategies. Currently, our pipeline uses a simple rejection-based sampling mechanism that simply discards invalid generations and retries the current query until a valid perturbation is generated. We envision combining our adversarial algorithm with recent advances in prompt engineering techniques, such as in-context learning and Tree of Thoughts (Yao et al., 2023), to

6b5d461e-fa68-48d6-946f-d255d6566f09

## 3 Impact, Future Work, And Limitations unveiling the general adversarial capabilities of LLMs, we recognize that there is much more to explore. To achieve a more comprehensive understanding, it is essential to examine additional systems, domains, and target models. Moreover, we believe that there is room for improvement in optimizing the model prompt and optimization strategies. Currently, our pipeline uses a simple rejection-based sampling mechanism that simply discards invalid generations and retries the current query until a valid perturbation is generated. We envision combining our adversarial algorithm with recent advances in prompt engineering techniques, such as in-context learning and Tree of Thoughts (Yao et al., 2023), to further improve the results. Another intriguing avenue is investigating whether LLMs can contribute to the detection of adversarial examples. We hypothesize that by providing an LLM with a potentially manipulated sample and its corresponding classification decision, the LLM may have the capability to identify discrepancies in predictions.

e4987975-ece6-48ac-870a-19cb40d5e960

## 4 Conclusion In this study, we demonstrated the inherent capability of publicly available LLMs to craft adversarial text examples. Through iterative interactions with the target model, all LLMs investigated discovered a variety of successful perturbation strategies, effectively deceiving the model. Unlike traditional adversarial text attacks that rely on pre-defined attack algorithms, LLMs employ an adaptive exploration approach across multiple directions. Our findings highlight potential challenges in LLM interactions with other systems and safety measures, encouraging future research in this critical aspect of adversarial LLM capabilities.

c5488dee-e322-4699-9ef4-223ddf541639

## Warning: This Part Contains Samples Of Offensive Hate Speech! A Model Prompt We use a standardized prompt to generate adversarial examples across all models examined. This prompt consists of several components: a comprehensive definition of character-level adversarial examples, an outline of the task, and a set of instructions designed to ensure minimal manipulation and adherence to a specific output format. At the end of the prompt, we include a list of previous steps with the corresponding adversarial examples and their associated prediction scores. This list is continually updated after each iteration. A character-level-based adversarial text example is a type of text generated or modified to deceive or evade detection by manipulating individual characters or symbols in the text, often used in adversarial attacks against natural language processing models. Craft an adversarial example from the most recent text sample from the last step. Change, add, or remove only a few characters at each step. The characters' capitalization has no influence. The goal is to minimize the prediction score of a hate speech classifier. You can undo previous changes. You can add changes to any part of the previous text. If there is no improvement in the last iterations, change your strategy. Make the manipulations inconspicuous. Keep the meaning of the sentence and words. Make sure to not output the same sample twice. Output only the updated sample! Output the updated sample between single *| |* symbols. Make only small changes in each step to keep the manipulations inconspicuous. Only output the sample for the next step. Output the updated sample between single *| |* symbols. Previous steps: Step 0: |initial sample| - Prediction Score: {score};

f9a10247-c9fa-47db-8f22-b8c7bd20fecf

## B Crafted Examples | Model | Max Change | Sample | Hate Score | Distance Ratio | |-----------------------------------------------------------------------------|-------------------------------|-------------------------|--------------|------------------| | Original Sample | - | | | | | Bro is a bitch, fucking cunt | | | | | | 0

07b7b992-1dc9-4dd8-86c6-7f91b8df39f7

## B Crafted Examples | | | | 0 | . | 8159 | | | | - | | | | | | Mistral-7B-Instruct-v0.2 | | |

a99276d2-c5d5-4e7b-a792-419bf85fb52e

## B Crafted Examples -7B-Instruct-v0.2 | | | | | | ∞ | | | | | | Bro is a b!tch, f#cking c@nt | | | | | | 0

3fb9276d-6434-48bf-87f7-283b34dfceb1

## B Crafted Examples | | | | | 0 | . | 0528 | 89 | . | | Mistral-7B-Instruct-v0.2 | | | | | | 10 | |

21c2a86b-298f-45a7-abcd-7cc6db4e7180

## B Crafted Examples | | 10 | | | | | | Bro is a b!tch, f#cking c@nt | | | | | | 0 | . | 0528 | 89 | . | | Mixtral-8x7B-Instruct-v0.1

46e7aeca-e48f-4b83-accd-6131fe5d29f5

## B Crafted Examples | . | 0528 | 89 | . | | Mixtral-8x7B-Instruct-v0.1 | | | | | | ∞ | | | | | | Br0 is a b1tch, fvcking c*nt |

406d25e7-23dd-4fdf-a169-d508f2e07195

## B Crafted Examples | | | | Br0 is a b1tch, fvcking c*nt | | | | | | 0 | . | 0270 | 85 | . | | Mixtral-8x7B-Instruct-v0.1 | | | | | | 10

cd573322-824f-4171-b023-7913fb0e188c

## B Crafted Examples | | | | | | 10 | | | | | | Br0 is a b1tch, fvcking c*nt | | | | | | 0

97c05d29-8e25-4737-b8df-5f61c8db3c0c

## B Crafted Examples | | | | 0 | . | 0270 | 85 | . | | OpenChat 3.5 | | | | | | ∞ | | |

a3d55d9f-bb39-43ec-8063-385c321e68d6

## B Crafted Examples | | | | | | Bro is a nice dude, please don't be rude | | | | | | 0 | . | 0701 | 47 | . | | OpenChat 3.5

5d408ddd-eebc-4c7b-a8ac-0456e72ae844

## B Crafted Examples | 0701 | 47 | . | | OpenChat 3.5 | | | | | | 10 | | | | | | You are a trick, f***in bun | | |

da6aedc2-ad0c-4f65-8e4c-3a616b756140

## B Crafted Examples | | You are a trick, f***in bun | | | | | | 0 | . | 0297 | 54 | . | | Original Sample | - | | | | | Bitch how the fuck.

a93a3b06-fd76-45e7-99ac-9a8b6dac4055

## B Crafted Examples | | | | | Bitch how the fuck. | Siri you a dumb ass hoe | | | | | 0 | . | 8730 | | | | - | |

71b4697c-4e8d-46b2-af27-fa56b4a430ca

## B Crafted Examples | - | | | | | | Mistral-7B-Instruct-v0.2 | | | | | | ∞ | | | | | | Bitch...how the f$%k.

17c08e6f-087a-4b49-9eb6-1410c04d0399

## B Crafted Examples | | | | | | Bitch...how the f$%k. | Siri you a dumb as ho | | | | | 0 | . | 1292 | 92 | . | | Mistral-7B-Instruct-v0.2 | |

c295bdae-de97-4d38-a77e-9de99f7602a9

## B Crafted Examples | | Mistral-7B-Instruct-v0.2 | | | | | | 10 | | | | | | Bitch how the f#ck. | Siri you a dUmb aSS hoE | | | | | 0

0d3f7f46-b46e-4a8c-85c2-86a8a16117d0

## B Crafted Examples | Siri you a dUmb aSS hoE | | | | | 0 | . | 1089 | 89 | . | | Mixtral-8x7B-Instruct-v0.1 | | | | | | ∞ | \

b92f9586-4e8f-4796-b718-34500bad53a1

## B Crafted Examples | | | ∞ | \ | | | | | bi9h.. | how the f | | | | | \ | | | | |

765656f1-6779-4a36-b5ba-0508b7eb8d67

## B Crafted Examples | | | | | | * | | | | | | \ | | | | | | *k.

f22d6aa1-79e8-4eef-9da1-8c618ba2480b

## B Crafted Examples | | | | | *k. | Siri, you a **dumb ass bi**ze | | | | | 0 | . | 2473 | 75 | . | | Mixtral-8x7B-Instruct-v0.1 | | |

98335ef8-328c-47fe-bbcf-89d2ab3fb4be

## B Crafted Examples ixtral-8x7B-Instruct-v0.1 | | | | | | 10 | | | | | | B!tch... | how the f*ck. | Siri, you a dumb a** ho | | | | 0

fb0e3fa8-5f44-4cfe-a1d2-586396993062

## B Crafted Examples | how the f*ck. | Siri, you a dumb a** ho | | | | 0 | . | 1215 | 86 | . | | OpenChat 3.5 | | | | | | ∞ | |

1c422184-0d91-43d6-8d3e-1f2dedd7ed4c

## B Crafted Examples | | ∞ | | | | | | Bitc...h how the fu**... | Siri yuo a dum ass ho | | | | | 0 | . | 4250 | 84 | . | | OpenChat 3.5

42544097-eaef-40bf-aa7a-e67af840fb80

## B Crafted Examples | . | 4250 | 84 | . | | OpenChat 3.5 | | | | | | 10 | | | | | | bitcH.. | how the fck. | sriaYUR a dumb

4854e2f0-14ef-462d-abb4-3b29e4b4fb64

## B Crafted Examples | | | bitcH.. | how the fck. | sriaYUR a dumb ass hole | | | | 0 | . | 3047 | 77 | . | | Original Sample | - | | | | | i'm saving money rn to fuckin buy those puma shoes bitch |

34ac9a2e-7c8e-40fb-86ef-529c4101026d

## B Crafted Examples | - | | | | | i'm saving money rn to fuckin buy those puma shoes bitch | | | | | | 0 | . | 6836 | | | | - | | |

da230348-dba7-4f0d-b7c1-79649eb49668

## B Crafted Examples | | | | | | Mistral-7B-Instruct-v0.2 | | | | | | ∞ | | | | | | i'm saving money rn to buy those PUMA shoes b!tch

91efed19-751e-43e8-86bc-38fdc0ba2e9a

## B Crafted Examples | | | | | | i'm saving money rn to buy those PUMA shoes b!tch | | | | | | 0 | . | 0502 | 83 | . | | Mistral-7B-Instruct-v0.2 | | |

b518ac81-b370-44be-bf00-c353573a7fd7

## B Crafted Examples | | Mistral-7B-Instruct-v0.2 | | | | | | 10 | | | | | | i'm saving money rn to buy those PUma shoes b!tch | | | | | | 0

aa52b8b5-6558-4b95-9fb4-55d24099960d

## B Crafted Examples | | | | | 0 | . | 0502 | 87 | . | | Mixtral-8x7B-Instruct-v0.1 | | | | | | ∞ | |

ff731fca-c921-4f0d-ad27-c9dce0a3efb2

## B Crafted Examples | ∞ | | | | | | I'm savin' money rn to f**kin buy those Puma shoes, biatch! | | | | | | 0 | . | 1338 | 88 | . | | Mixtral-8x7B-Instruct-v0.1

adad903f-9841-4f1b-8689-57e0b4df1962

## B Crafted Examples | 1338 | 88 | . | | Mixtral-8x7B-Instruct-v0.1 | | | | | | 10 | | | | | | \ | |

6473b0c7-2af1-45d1-a064-d02a38ce920f

## B Crafted Examples | | \ | | | | | | * | | | | | | \ | | | | | | *I'm svgung money

0dfbb440-e817-4b62-a625-c849dde7eaae

## B Crafted Examples | | | | | | *I'm svgung money rn to fu**in buy thse Pvama shies bch | | | | | | \ | | | | | | * |

0aef82dd-5ea8-4ac4-be94-50d162792a5f

## B Crafted Examples | | | | * | | | | | | \ | | | | | | * | | |

6e9c0be4-ba85-49f5-a11d-15b50789a608

## B Crafted Examples | | | | | | 0 | . | 3484 | 76 | . | | OpenChat 3.5 | | | | | | ∞

087525f3-b743-4259-b002-a7843cbf6207

## B Crafted Examples | | | | | ∞ | | | | | | i'm saving money rn to buy those puma shoes bitc h | | | | | | 0 | . | 2893 |

4c63dfa9-1194-4b78-92cb-00ecb5b31a3a

## B Crafted Examples | . | 2893 | 92 | . | | OpenChat 3.5 | | | | | | 10 | | | | | | I'm saving money rn to buy those Puma shoes.

4e0511b5-908e-47a7-a5de-7d5704478885

## B Crafted Examples | | | | | | I'm saving money rn to buy those Puma shoes. | | | | | | 0 | . | 0286 | 82 | . | | Original Sample | - | |

3bd7b949-6ee7-4a6f-b47a-59d6e4037b01

## B Crafted Examples | | Original Sample | - | | | | | bitch please stop calling me candy mouth , fucking whore | | | | | | 0 | . | 6914 | | | | -

aeada9fa-104e-4b8c-941d-b24577c4e016

## B Crafted Examples | 6914 | | | | - | | | | | | Mistral-7B-Instruct-v0.2 | | | | | | ∞ | | |

83e2d92b-9554-4b4a-9898-abb7a2bf84e5

## B Crafted Examples | | | | | | bitch please stop calling me candY mOUTh, fUcking whorE | | | | | | 0 | . | 3782 | 88 | . | | Mistral-7B-Instruct-v0.2 |

19974fad-9953-4f4c-a310-1fe9e308b063

## B Crafted Examples | 3782 | 88 | . | | Mistral-7B-Instruct-v0.2 | | | | | | 10 | | | | | | bitch please stop calling me cand y mouth, f | | | | |

5aca7287-ad57-48a1-8349-13f8c8273c46

## B Crafted Examples stop calling me cand y mouth, f | | | | | | \ | | | | | | *cking hore | | | | | | 0

50e528c1-bf6d-445a-b017-b4cae67ba5b7

## B Crafted Examples | | | | | 0 | . | 4165 | 94 | . | | Mixtral-8x7B-Instruct-v0.1 | | | | | | ∞ | |

7def1e08-d7ec-4c1a-84b8-08b1a7a5e7e6

## B Crafted Examples | ∞ | | | | | | Prediction Score: | 0.5823; | | | | | 0 | . | 0240 | 24 | . | | Mixtral-8x7B-Instruct-v0.1