# A Survey of Hallucination in “Large” Foundation Models

Vipula Rawte1, Amit Sheth1, Amitava Das1
1AI Institute, University of South Carolina, USA
<EMAIL_ADDRESS>corresponding author

###### Abstract

Hallucination in a foundation model (FM) refers to the generation of content
that strays from factual reality or includes fabricated information. This
survey paper provides an extensive overview of recent efforts that aim to
identify, elucidate, and tackle the problem of hallucination, with a
particular focus on “Large” Foundation Models (LFMs). The paper classifies
various types of hallucination phenomena that are specific to LFMs and
establishes evaluation criteria for assessing the extent of hallucination. It
also examines existing strategies for mitigating hallucination in LFMs and
discusses potential directions for future research in this area. Essentially,
the paper offers a comprehensive examination of the challenges and solutions
related to hallucination in LFMs.

##  1 Introduction

Foundation Models (FMs), exemplified by GPT-3 Brown et al. (2020) and Stable
Diffusion Rombach et al. (2022), marks the commencement of a novel era in the
realm of machine learning and generative artificial intelligence. Researchers
introduced the term “foundation model” to describe machine learning models
that are trained on extensive, diverse, and unlabeled data, enabling them to
proficiently handle a wide array of general tasks. These tasks encompass
language comprehension, text and image generation, and natural language
conversation.

###  1.1 What is a Foundation Model

Foundation models refer to massive AI models trained on extensive volumes of
unlabeled data, typically through self-supervised learning. This training
approach yields versatile models capable of excelling in a diverse range of
tasks, including image classification, natural language processing, and
question-answering, achieving remarkable levels of accuracy.

These models excel in tasks involving generative abilities and human
interaction, such as generating marketing content or producing intricate
artwork based on minimal prompts. However, adapting and implementing these
models for enterprise applications can present certain difficulties Bommasani
et al. (2021).

###  1.2 What is Hallucination in Foundation Model?

Hallucination in the context of a foundation model refers to a situation where
the model generates content that is not based on factual or accurate
information. Hallucination can occur when the model produces text that
includes details, facts, or claims that are fictional, misleading, or entirely
fabricated, rather than providing reliable and truthful information.

This issue arises due to the model’s ability to generate plausible-sounding
text based on patterns it has learned from its training data, even if the
generated content does not align with reality. Hallucination can be
unintentional and may result from various factors, including biases in the
training data, the model’s lack of access to real-time or up-to-date
information, or the inherent limitations of the model in comprehending and
generating contextually accurate responses.

Addressing hallucination in foundation models and LLMs is crucial, especially
in applications where factual accuracy is paramount, such as journalism,
healthcare, and legal contexts. Researchers and developers are actively
working on techniques to mitigate hallucinations and improve the reliability
and trustworthiness of these models. With the recent rise in this problem Fig.
2, it has become even more critical to address them.

###  1.3 Why this survey?

In recent times, there has been a significant surge of interest in LFMs within
both academic and industrial sectors. Additionally, one of their main
challenges is hallucination. The survey in Ji et al. (2023) describes
hallucination in natural language generation. In the era of large models,
Zhang et al. (2023c) have done another great timely survey studying
hallucination in LLMs. However, besides not only in LLMs, the problem of
hallucination also exists in other foundation models such as image, video, and
audio as well. Thus, in this paper, we do the first comprehensive survey of
hallucination across all major modalities of foundation models.

####  1.3.1 Our contributions

The contributions of this survey paper are as follows:

  1. 1.

We succinctly categorize the existing works in the area of hallucination in
LFMs, as shown in Fig. 1.

  2. 2.

We offer an extensive examination of large foundation models (LFMs) in
Sections 2, 3, 4 and 5.

  3. 3.

We cover all the important aspects such as i. detection, ii. mitigation, iii.
tasks, iv. datasets, and v. evaluation metrics, given in LABEL:tab:big-table.

  4. 4.

We finally also provide our views and possible future direction in this area.
We will regularly update the associated open-source resources, available for
access at https://github.com/vr25/hallucination-foundation-model-survey

for tree= forked edges, grow’=0, draw, rounded corners, node
options=align=center,, text width=2.7cm, , [Hallucination in Large Foundation
Models, fill=gray!10, parent [Text, for tree=fill=orange!60, child [LLMs,
fill=orange!45, grandchild[Li et al. (2023b); Mündler et al. (2023); Zhang et
al. (2023b); Peng et al. (2023); Li et al. (2023d); Elaraby et al. (2023); Jha
et al. (2023); McKenna et al. (2023); Varshney et al. (2023); Huang and Chang
(2023); Luo et al. (2023); Gao et al. (2023), fill=orange!30, greatgrandchild
] ] [Multilingual LLMs, fill=orange!45, grandchild [Pfeiffer et al. (2023);
Cui et al. (2023), fill=orange!30, greatgrandchild ] ] [Domain-specific LLMs,
fill=orange!45, grandchild [Medical: Umapathi et al. (2023), Law: Cui et al.
(2023), fill=orange!30, greatgrandchild ] ] ] [Image, for
tree=fill=yellow!45,child [Li et al. (2023e); Gunjal et al. (2023); Wu et al.
(2023), fill=yellow!30, greatgrandchild] ] [Video, for tree=fill=purple!45,
child [Himakunthala et al. (2023); Kulal et al. (2023); Li et al. (2023c); Yu
et al. (2023); Liu and Wan (2023), fill=purple!30, greatgrandchild] ] [Audio,
for tree=fill=green!45, child [Doh et al. (2023); Li et al. (2023a),
fill=green!30, greatgrandchild] ] ]

Figure 1: Taxonomy for Hallucination in Large Foundation Models

####  1.3.2 Classification of Hallucination

As shown in Fig. 1, we broadly classify the LFMs into four types as follows:
i. Text, ii. Image, iii. video, and iv. Audio.

The paper follows the following structure. Based on the above classification,
we describe the hallucination and mitigation techniques for all four
modalities in: i. text (Section 2), ii. image (Section 3), iii. video (Section
4), and iv. audio (Section 5). In Section 6, we briefly discuss how
hallucinations are NOT always bad, and hence, in the creative domain, they can
be well-suited to producing artwork. Finally, we give some possible future
directions for addressing this issue along with a conclusion in Section 7.

Figure 2: The evolution of “hallucination” papers for Large Foundation Models
(LFMs) from March 2023 to September 2023.

##  2 Hallucination in Large Language Models

As shown in Fig. 4, hallucination occurs when the LLM produces fabricated
responses.

Figure 3: An illustration of hallucination Luo et al. (2023). Incorrect
information is highlighted in Red.

###  2.1 LLMs

SELFCHECKGPT Manakul et al. (2023), is a method for zero-resource black-box
hallucination detection in generative LLMs. This technique focuses on
identifying instances where these models generate inaccurate or unverified
information without relying on additional resources or labeled data. It aims
to enhance the trustworthiness and reliability of LLMs by providing a
mechanism to detect and address hallucinations without external guidance or
datasets. Self-contradictory hallucinations in LLMs are explored in Mündler et
al. (2023). and addresses them through evaluation, detection, and mitigation
techniques. It refers to situations where LLMs generate text that contradicts
itself, leading to unreliable or nonsensical outputs. This work presents
methods to evaluate the occurrence of such hallucinations, detect them in LLM-
generated text, and mitigate their impact to improve the overall quality and
trustworthiness of LLM-generated content.

PURR Chen et al. (2023) is a method designed to efficiently edit and correct
hallucinations in language models. PURR leverages denoising language model
corruptions to identify and rectify these hallucinations effectively. This
approach aims to enhance the quality and accuracy of language model outputs by
reducing the prevalence of hallucinated content.

##### Hallucination datasets:

Hallucinations are commonly linked to knowledge gaps in language models (LMs).
However, Zhang et al. (2023a) proposed a hypothesis that in certain instances
when language models attempt to rationalize previously generated
hallucinations, they may produce false statements that they can independently
identify as inaccurate. Thus, they created three question-answering datasets
where ChatGPT and GPT-4 frequently provide incorrect answers and accompany
them with explanations that contain at least one false assertion.

HaluEval Li et al. (2023b), is a comprehensive benchmark designed for
evaluating hallucination in LLMs. It serves as a tool to systematically assess
LLMs’ performance in terms of hallucination across various domains and
languages, helping researchers and developers gauge and improve the
reliability of these models.

##### Hallucination mitigation using external knowledge:

Using interactive question-knowledge alignment, Zhang et al. (2023b) presents
a method for mitigating language model hallucination Their proposed approach
focuses on aligning generated text with relevant factual knowledge, enabling
users to interactively guide the model’s responses to produce more accurate
and reliable information. This technique aims to improve the quality and
factuality of language model outputs by involving users in the alignment
process. LLM-AUGMENTER Peng et al. (2023) improves LLMs using external
knowledge and automated feedback. It highlights the need to address the
limitations and potential factual errors in LLM-generated content. This method
involves incorporating external knowledge sources and automated feedback
mechanisms to enhance the accuracy and reliability of LLM outputs. By doing
so, the paper aims to mitigate factual inaccuracies and improve the overall
quality of LLM-generated text. Similarly, Li et al. (2023d) introduces a
framework called “Chain of Knowledge” for grounding LLMs with structured
knowledge bases. Grounding refers to the process of connecting LLM-generated
text with structured knowledge to improve factual accuracy and reliability.
The framework utilizes a hierarchical approach, chaining multiple knowledge
sources together to provide context and enhance the understanding of LLMs.
This approach aims to improve the alignment of LLM-generated content with
structured knowledge, reducing the risk of generating inaccurate or
hallucinated information.

Smaller, open-source LLMs with fewer parameters often experience significant
hallucination issues compared to their larger counterparts Elaraby et al.
(2023). This work focuses on evaluating and mitigating hallucinations in BLOOM
7B, which represents weaker open-source LLMs used in research and commercial
applications. They introduce HALOCHECK, a lightweight knowledge-free framework
designed to assess the extent of hallucinations in LLMs. Additionally, it
explores methods like knowledge injection and teacher-student approaches to
reduce hallucination problems in low-parameter LLMs.

Moreover, the risks associated with LLMs can be mitigated by drawing parallels
with web systems Huang and Chang (2023). It highlights the absence of a
critical element, “citation,” in LLMs, which could improve content
transparency, and verifiability, and address intellectual property and ethical
concerns.

##### Hallucination mitigation using prompting techniques:

“Dehallucinating” refers to reducing the generation of inaccurate or
hallucinated information by LLMs. Dehallucinating LLMs using formal methods
guided by iterative prompting is presented in Jha et al. (2023). They employ
formal methods to guide the generation process through iterative prompts,
aiming to improve the accuracy and reliability of LLM outputs. This method is
designed to mitigate the issues of hallucination and enhance the
trustworthiness of LLM-generated content.

###  2.2 Multilingual LLMs

Large-scale multilingual machine translation systems have shown impressive
capabilities in directly translating between numerous languages, making them
attractive for real-world applications. However, these models can generate
hallucinated translations, which pose trust and safety issues when deployed.
Existing research on hallucinations has mainly focused on small bilingual
models for high-resource languages, leaving a gap in understanding
hallucinations in massively multilingual models across diverse translation
scenarios.

To address this gap, Pfeiffer et al. (2023) conducted a comprehensive analysis
on both the M2M family of conventional neural machine translation models and
ChatGPT, a versatile LLM that can be prompted for translation. The
investigation covers a wide range of conditions, including over 100
translation directions, various resource levels, and languages beyond English-
centric pairs.

###  2.3 Domain-specific LLMs

Hallucinations in mission-critical areas such as medicine, banking, finance,
law, and clinical settings refer to instances where false or inaccurate
information is generated or perceived, potentially leading to serious
consequences. In these sectors, reliability and accuracy are paramount, and
any form of hallucination, whether in data, analysis, or decision-making, can
have significant and detrimental effects on outcomes and operations.
Consequently, robust measures and systems are essential to minimize and
prevent hallucinations in these high-stakes domains.

##### Medicine:

The issue of hallucinations in LLMs, particularly in the medical field, where
generating plausible yet inaccurate information can be detrimental. To tackle
this problem, Umapathi et al. (2023) introduces a new benchmark and dataset
called Med-HALT (Medical Domain Hallucination Test). It is specifically
designed to evaluate and mitigate hallucinations in LLMs. It comprises a
diverse multinational dataset sourced from medical examinations across
different countries and includes innovative testing methods. Med-HALT consists
of two categories of tests: reasoning and memory-based hallucination tests,
aimed at assessing LLMs’ problem-solving and information retrieval
capabilities in medical contexts.

##### Law:

ChatLaw Cui et al. (2023), is an open-source LLM specialized for the legal
domain. To ensure high-quality data, the authors created a meticulously
designed legal domain fine-tuning dataset. To address the issue of model
hallucinations during legal data screening, they propose a method that
combines vector database retrieval with keyword retrieval. This approach
effectively reduces inaccuracies that may arise when solely relying on vector
database retrieval for reference data retrieval in legal contexts.

##  3 Hallucination in Large Image Models

Figure 4: Instances of object hallucination within LVLMs Li et al. (2023e).
Ground-truth objects in annotations are indicated in bold, while red objects
represent hallucinated objects by LVLMs. The left case occurs in the
conventional instruction-based evaluation approach, while the right cases
occur in three variations of POPE.

Contrastive learning models, employing a Siamese structure Wu et al. (2023),
have displayed impressive performance in self-supervised learning. Their
success hinges on two crucial conditions: the presence of a sufficient number
of positive pairs and the existence of ample variations among them. Without
meeting these conditions, these frameworks may lack meaningful semantic
distinctions and become susceptible to overfitting. To tackle these
challenges, we introduce the Hallucinator, which efficiently generates
additional positive samples to enhance contrast. The Hallucinator is
differentiable, operating in the feature space, making it amenable to direct
optimization within the pre-training task and incurring minimal computational
overhead.

Efforts to enhance LVLMs for complex multimodal tasks, inspired by LLMs, face
a significant challenge: object hallucination, where LVLMs generate
inconsistent objects in descriptions. This study Li et al. (2023e)
systematically investigates object hallucination in LVLMs and finds it’s a
common issue. Visual instructions, especially frequently occurring or co-
occurring objects, influence this problem. Existing evaluation methods are
also affected by input instructions and LVLM generation styles. To address
this, the study introduces an improved evaluation method called POPE,
providing a more stable and flexible assessment of object hallucination in
LVLMs.

Instruction-tuned Large Vision Language Models (LVLMs) have made significant
progress in handling various multimodal tasks, including Visual Question
Answering (VQA). However, generating detailed and visually accurate responses
remains a challenge for these models. Even state-of-the-art LVLMs like
InstructBLIP exhibit a high rate of hallucinatory text, comprising 30 percent
of non-existent objects, inaccurate descriptions, and erroneous relationships.
To tackle this issue, the study Gunjal et al. (2023)introduces MHalDetect1, a
Multimodal Hallucination Detection Dataset designed for training and
evaluating models aimed at detecting and preventing hallucinations.
M-HalDetect contains 16,000 finely detailed annotations on VQA examples,
making it the first comprehensive dataset for detecting hallucinations in
detailed image descriptions.

##  4 Hallucination in Large Video Models

Hallucinations can occur when the model makes incorrect or imaginative
assumptions about the video frames, leading to the creation of artificial or
erroneous visual information Fig. 5.

Figure 5: A video featuring three captions generated by various captioning
models Liu and Wan (2023), with factual errors highlighted in red italics.

The challenge of understanding scene affordances is tackled by introducing a
method for inserting people into scenes in a lifelike manner Kulal et al.
(2023). Using an image of a scene with a marked area and an image of a person,
the model seamlessly integrates the person into the scene while considering
the scene’s characteristics. The model is capable of deducing realistic poses
based on the scene context, adjusting the person’s pose accordingly, and
ensuring a visually pleasing composition. The self-supervised training enables
the model to generate a variety of plausible poses while respecting the
scene’s context. Additionally, the model can also generate lifelike people and
scenes on its own, allowing for interactive editing.

VideoChat Li et al. (2023c), is a comprehensive system for understanding
videos with a chat-oriented approach. VideoChat combines foundational video
models with LLMs using an adaptable neural interface, showcasing exceptional
abilities in understanding space, time, event localization, and inferring
cause-and-effect relationships. To fine-tune this system effectively, they
introduced a dataset specifically designed for video-based instruction,
comprising thousands of videos paired with detailed descriptions and
conversations. This dataset places emphasis on skills like spatiotemporal
reasoning and causal relationships, making it a valuable resource for training
chat-oriented video understanding systems.

Recent advances in video inpainting have been notable Yu et al. (2023),
particularly in cases where explicit guidance like optical flow can help
propagate missing pixels across frames. However, challenges arise when cross-
frame information is lacking, leading to shortcomings. So, instead of
borrowing pixels from other frames, the model focuses on addressing the
reverse problem. This work introduces a dual-modality-compatible inpainting
framework called Deficiency-aware Masked Transformer (DMT). Pretraining an
image inpainting model to serve as a prior for training the video model has an
advantage in improving the handling of situations where information is
deficient.

Video captioning aims to describe video events using natural language, but it
often introduces factual errors that degrade text quality. While factuality
consistency has been studied extensively in text-to-text tasks, it received
less attention in vision-based text generation. In this research Liu and Wan
(2023), the authors conducted a thorough human evaluation of factuality in
video captioning, revealing that 57.0% of model-generated sentences contain
factual errors. Existing evaluation metrics, mainly based on n-gram matching,
do not align well with human assessments. To address this issue, they
introduced a model-based factuality metric called FactVC, which outperforms
previous metrics in assessing factuality in video captioning.

##  5 Hallucination in Large Audio Models

Automatic music captioning, which generates text descriptions for music
tracks, has the potential to enhance the organization of vast musical data.
However, researchers encounter challenges due to the limited size and
expensive collection process of existing music-language datasets. To address
this scarcity, Doh et al. (2023) used LLMs to generate descriptions from
extensive tag datasets. They created a dataset known as LP-MusicCaps,
comprising around 2.2 million captions paired with 0.5 million audio clips.
They also conducted a comprehensive evaluation of this large-scale music
captioning dataset using various quantitative natural language processing
metrics and human assessment. They trained a transformer-based music
captioning model on this dataset and evaluated its performance in zero-shot
and transfer-learning scenarios.

Ideally, the video should enhance the audio, and in Li et al. (2023a), they
have used an advanced language model for data augmentation without human
labeling. Additionally, they utilized an audio encoding model to efficiently
adapt a pre-trained text-to-image generation model for text-to-audio
generation.

##  6 Hallucination is _not_ always harmful: A different perspective

Suggesting an alternative viewpoint, Wiggers (2023) discusses how
hallucinating models could serve as “collaborative creative partners,”
offering outputs that may not be entirely grounded in fact but still provide
valuable threads to explore. Leveraging hallucination creatively can lead to
results or novel combinations of ideas that might not readily occur to most
individuals.

“Hallucinations” become problematic when the statements generated are
factually inaccurate or contravene universal human, societal, or particular
cultural norms. This is especially critical in situations where an individual
relies on the LLM to provide expert knowledge. However, in the context of
creative or artistic endeavors, the capacity to generate unforeseen outcomes
can be quite advantageous. Unexpected responses to queries can surprise humans
and stimulate the discovery of novel idea connections.

Table 1: Summary of all the works related to hallucination in all four modalities of the large foundation models. Here, we have divided each work by the following factors: 1. Detection, 2. Mitigation, 3. Tasks, 4. Datasets, and 5. Evaluation metrics.  indicates that it is present in the paper whereas  indicates it is not present. |  Title |  Detect |  Mitigate |  Task(s) |  Dataset |  Evaluation Metric
---|---|---|---|---|---|---
TEXT |  SELFCHECKGPT: Zero-Resource Black-Box Hallucination Detection for Generative Large Language Models Manakul et al. (2023) |  |  |  QA |  Manual (WikiBio) |  Token probability or entropy
HaluEval: A Large-Scale Hallucination Evaluation Benchmark for Large Language Models Li et al. (2023b) |  |  |  QA, Dialogue Summarization, General |  HaluEval |  Automatic
Self-contradictory Hallucinations of Large Language Models: Evaluation, Detection and Mitigation Mündler et al. (2023) |  |  |  Text generation |  Manual |  F1 score
PURR: Efficiently Editing Language Model Hallucinations by Denoising Language Model Corruptions Chen et al. (2023) |  |  |  Editing for Attribution |  Multiple question answering, Dialog datasets |  Attribution, Preservation
Mitigating Language Model Hallucination with Interactive Question-Knowledge Alignment Zhang et al. (2023b) |  |  |  Question-knowledge alignment |  FuzzyQA |  Attributable to Identified Sources Castaldo and Yang (2007)
How Language Model Hallucinations Can Snowball Zhang et al. (2023a) |  |  |  QA |  Manual |  Accuracy
Check Your Facts and Try Again: Improving Large Language Models with External Knowledge and Automated Feedback Peng et al. (2023) |  |  |  Task oriented dialog and open-domain question answering |  News Chat, Customer Service |  Knowledge F1 (KF1) and BLEU-4
ChatLawLLM Cui et al. (2023) |  |  |  QA |  Manual |  ELO model ranking
The Internal State of an LLM Knows When its Lying Azaria and Mitchell (2023) |  |  |  Classificati-on |  Manual |  Accuracy
Chain of Knowledge: A Framework for Grounding Large Language Models with Structured Knowledge Bases Li et al. (2023d) |  |  |  Knowledge intensive tasks |  FEVER, AdvHotpotQA |  Accuracy
HALO: Estimation and Reduction of Hallucinations in Open-Source Weak Large Language Models Elaraby et al. (2023) |  |  |  Consistency, Factuality, BS, QA, NLI |  Manual on NBA domain |  Pearson and Kendall tau correlation coefficients
A Stitch in Time Saves Nine: Detecting and Mitigating Hallucinations of LLMs by Validating Low-Confidence Generation Varshney et al. (2023) |  |  |  Article generation |  WikiBio |  Percentage of mitigated hallucinations
Dehallucinating Large Language Models Using Formal Methods Guided Iterative Prompting Jha et al. (2023) |  |  |  Dialog |  - |  -
Med-HALT: Medical Domain Hallucination Test for Large Language Models Umapathi et al. (2023) |  |  |  Reasoning Hallucination Test (RHT), Memory Hallucination Test (MHT) |  Med-HALT |  Accuracy, Pointwise score
Sources of Hallucination by Large Language Models on Inference Tasks McKenna et al. (2023) |  |  |  Textual entailment |  Altered directional inference adatset |  Enatilment probability
Hallucinations in Large Multilingual Translation Models Pfeiffer et al. (2023) |  |  |  MT |  FLORES-101, WMT, and TICO |  spBLEU
Citation: A Key to Building Responsible and Accountable Large Language Models Huang and Chang (2023) |  |  |  N/A |  N/A |  N/A
Zero-resource hallucination prevention for large language models Luo et al. (2023) |  |  |  Concept extraction, guessing, aggregation |  Concept-7 |  AUC, ACC, F1, PEA
RARR: Researching and Revising What Language Models Say, Using Language Models Gao et al. (2023) |  |  |  Editing for Attribution |  NQ, SQA, QReCC |  Attributable to Identified Sources Castaldo and Yang (2007)
IMAGE |  Evaluating Object Hallucination in Large Vision-Language Models Li et al. (2023e) |  |  |  Image captioning |  MSCOCO Lin et al. (2014) |  Caption Hallucination Assessment with Image Relevance (CHAIR) Rohrbach et al. (2018)
Detecting and Preventing Hallucinations in Large Vision Language Models Gunjal et al. (2023) |  |  |  Visual Question Answering (VQA) |  M-HalDetect |  Accuracy
Plausible May Not Be Faithful: Probing Object Hallucination in Vision-Language Pre-training Dai et al. (2022) |  |  |  Image captioning |  CHAIR Rohrbach et al. (2018) |  CIDEr
VIDEO |  Let’s Think Frame by Frame: Evaluating Video Chain of Thought with Video Infilling and Prediction Himakunthala et al. (2023) |  |  |  Video infilling, Scene prediction |  Manual |  N/A
Putting People in Their Place: Affordance-Aware Human Insertion into Scenes Kulal et al. (2023) |  |  |  Affordance prediction |  Manual (2.4M video clips) |  FID, PCKh
VideoChat : Chat-Centric Video Understanding Li et al. (2023c) |  |  |  Visual dialogue |  Manual |  N/A
Models See Hallucinations: Evaluating the Factuality in Video Captioning Liu and Wan (2023) |  |  |  Video captioning |  ActivityNet Captions Krishna et al. (2017), YouCook2 Krishna et al. (2017) |  Factual consistency for Video Captioning (FactVC)
AUDIO |  LP-MusicCaps: LLM-based pseudo music captioning Doh et al. (2023) |  |  |  Audio Captioning |  LP-MusicCaps |  BLEU1 to 4 (B1, B2, B3, B4), METEOR (M), and ROUGE-L (R-L)
Audio-Journey: Efficient Visual+LLM-aided Audio Encodec Diffusion Li et al. (2023a) |  |  |  Classificati-on |  Manual |  Mean average precision (mAP)

##  7 Conclusion and Future Directions

We concisely classify the existing research in the field of hallucination
within LFMs. We provide an in-depth analysis of these LFMs, encompassing
critical aspects including 1. Detection, 2. Mitigation, 3. Tasks, 4. Datasets,
and 5. Evaluation metrics.

Some possible future directions to address the hallucination challenge in the
LFMs are given below.

###  7.1 Automated Evaluation of Hallucination

In the context of natural language processing and machine learning,
hallucination refers to the generation of incorrect or fabricated information
by AI models. This can be a significant problem, especially in applications
like text generation, where the goal is to provide accurate and reliable
information. Here are some potential future directions in the automated
evaluation of hallucination:

##### Development of Evaluation Metrics:

Researchers can work on creating specialized evaluation metrics that are
capable of detecting hallucination in generated content. These metrics may
consider factors such as factual accuracy, coherence, and consistency.
Advanced machine learning models could be trained to assess generated text
against these metrics.

##### Human-AI Collaboration:

Combining human judgment with automated evaluation systems can be a promising
direction. Crowdsourcing platforms can be used to gather human assessments of
AI-generated content, which can then be used to train models for automated
evaluation. This hybrid approach can help in capturing nuances that are
challenging for automated systems alone.

##### Adversarial Testing:

Researchers can develop adversarial testing methodologies where AI systems are
exposed to specially crafted inputs designed to trigger hallucination. This
can help in identifying weaknesses in AI models and improving their robustness
against hallucination.

##### Fine-Tuning Strategies:

Fine-tuning pre-trained language models specifically to reduce hallucination
is another potential direction. Models can be fine-tuned on datasets that
emphasize fact-checking and accuracy to encourage the generation of more
reliable content.

###  7.2 Improving Detection and Mitigation Strategies with Curated Sources of
Knowledge

Detecting and mitigating issues like bias, misinformation, and low-quality
content in AI-generated text is crucial for responsible AI development.
Curated sources of knowledge can play a significant role in achieving this.
Here are some future directions:

##### Knowledge Graph Integration:

Incorporating knowledge graphs and curated knowledge bases into AI models can
enhance their understanding of factual information and relationships between
concepts. This can aid in both content generation and fact-checking.

##### Fact-Checking and Verification Models:

Develop specialized models that focus on fact-checking and content
verification. These models can use curated sources of knowledge to cross-
reference generated content and identify inaccuracies or inconsistencies.

##### Bias Detection and Mitigation:

Curated sources of knowledge can be used to train AI models to recognize and
reduce biases in generated content. AI systems can be programmed to check
content for potential biases and suggest more balanced alternatives.

##### Active Learning:

Continuously update and refine curated knowledge sources through active
learning. AI systems can be designed to seek human input and validation for
ambiguous or new information, thus improving the quality of curated knowledge.

##### Ethical Guidelines and Regulation:

Future directions may also involve the development of ethical guidelines and
regulatory frameworks for the use of curated knowledge sources in AI
development. This could ensure responsible and transparent use of curated
knowledge to mitigate potential risks.

In summary, these future directions aim to address the challenges of
hallucination detection and mitigation, as well as the responsible use of
curated knowledge to enhance the quality and reliability of AI-generated
content. They involve a combination of advanced machine learning techniques,
human-AI collaboration, and ethical considerations to ensure AI systems
produce accurate and trustworthy information.

## References

  * Azaria and Mitchell (2023) Amos Azaria and Tom Mitchell. 2023.  The internal state of an llm knows when its lying.  _arXiv preprint arXiv:2304.13734_.
  * Bommasani et al. (2021) Rishi Bommasani, Drew A Hudson, Ehsan Adeli, Russ Altman, Simran Arora, Sydney von Arx, Michael S Bernstein, Jeannette Bohg, Antoine Bosselut, Emma Brunskill, et al. 2021.  On the opportunities and risks of foundation models.  _arXiv preprint arXiv:2108.07258_.
  * Brown et al. (2020) Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. 2020.  Language models are few-shot learners.  _Advances in neural information processing systems_ , 33:1877–1901.
  * Castaldo and Yang (2007) Eric T Castaldo and Edmund Y Yang. 2007.  Severe sepsis attributable to community-associated methicillin-resistant staphylococcus aureus: an emerging fatal problem.  _The American Surgeon_ , 73(7):684–687.
  * Chen et al. (2023) Anthony Chen, Panupong Pasupat, Sameer Singh, Hongrae Lee, and Kelvin Guu. 2023\.  Purr: Efficiently editing language model hallucinations by denoising language model corruptions.
  * Cui et al. (2023) Jiaxi Cui, Zongjian Li, Yang Yan, Bohua Chen, and Li Yuan. 2023.  Chatlaw: Open-source legal large language model with integrated external knowledge bases.  _arXiv preprint arXiv:2306.16092_.
  * Dai et al. (2022) Wenliang Dai, Zihan Liu, Ziwei Ji, Dan Su, and Pascale Fung. 2022.  Plausible may not be faithful: Probing object hallucination in vision-language pre-training.  _arXiv preprint arXiv:2210.07688_.
  * Doh et al. (2023) SeungHeon Doh, Keunwoo Choi, Jongpil Lee, and Juhan Nam. 2023.  Lp-musiccaps: Llm-based pseudo music captioning.  _arXiv preprint arXiv:2307.16372_.
  * Elaraby et al. (2023) Mohamed Elaraby, Mengyin Lu, Jacob Dunn, Xueying Zhang, Yu Wang, and Shizhu Liu. 2023.  Halo: Estimation and reduction of hallucinations in open-source weak large language models.  _arXiv preprint arXiv:2308.11764_.
  * Gao et al. (2023) Luyu Gao, Zhuyun Dai, Panupong Pasupat, Anthony Chen, Arun Tejasvi Chaganty, Yicheng Fan, Vincent Zhao, Ni Lao, Hongrae Lee, Da-Cheng Juan, et al. 2023.  Rarr: Researching and revising what language models say, using language models.  In _Proceedings of the 61st Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers)_ , pages 16477–16508.
  * Gunjal et al. (2023) Anisha Gunjal, Jihan Yin, and Erhan Bas. 2023.  Detecting and preventing hallucinations in large vision language models.  _arXiv preprint arXiv:2308.06394_.
  * Himakunthala et al. (2023) Vaishnavi Himakunthala, Andy Ouyang, Daniel Rose, Ryan He, Alex Mei, Yujie Lu, Chinmay Sonar, Michael Saxon, and William Yang Wang. 2023.  Let’s think frame by frame: Evaluating video chain of thought with video infilling and prediction.  _arXiv preprint arXiv:2305.13903_.
  * Huang and Chang (2023) Jie Huang and Kevin Chen-Chuan Chang. 2023.  Citation: A key to building responsible and accountable large language models.  _arXiv preprint arXiv:2307.02185_.
  * Jha et al. (2023) Susmit Jha, Sumit Kumar Jha, Patrick Lincoln, Nathaniel D Bastian, Alvaro Velasquez, and Sandeep Neema. 2023.  Dehallucinating large language models using formal methods guided iterative prompting.  In _2023 IEEE International Conference on Assured Autonomy (ICAA)_ , pages 149–152. IEEE.
  * Ji et al. (2023) Ziwei Ji, Nayeon Lee, Rita Frieske, Tiezheng Yu, Dan Su, Yan Xu, Etsuko Ishii, Ye Jin Bang, Andrea Madotto, and Pascale Fung. 2023.  Survey of hallucination in natural language generation.  _ACM Computing Surveys_ , 55(12):1–38.
  * Krishna et al. (2017) Ranjay Krishna, Kenji Hata, Frederic Ren, Li Fei-Fei, and Juan Carlos Niebles. 2017\.  Dense-captioning events in videos.  In _Proceedings of the IEEE international conference on computer vision_ , pages 706–715.
  * Kulal et al. (2023) Sumith Kulal, Tim Brooks, Alex Aiken, Jiajun Wu, Jimei Yang, Jingwan Lu, Alexei A Efros, and Krishna Kumar Singh. 2023.  Putting people in their place: Affordance-aware human insertion into scenes.  In _Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition_ , pages 17089–17099.
  * Li et al. (2023a) Juncheng B Li, Jackson Sam Michaels, Laura Yao, Lijun Yu, Zach Wood-Doughty, and Florian Metze. 2023a.  Audio-journey: Efficient visual+ llm-aided audio encodec diffusion.  In _Workshop on Efficient Systems for Foundation Models@ ICML2023_.
  * Li et al. (2023b) Junyi Li, Xiaoxue Cheng, Wayne Xin Zhao, Jian-Yun Nie, and Ji-Rong Wen. 2023b.  Helma: A large-scale hallucination evaluation benchmark for large language models.  _arXiv preprint arXiv:2305.11747_.
  * Li et al. (2023c) KunChang Li, Yinan He, Yi Wang, Yizhuo Li, Wenhai Wang, Ping Luo, Yali Wang, Limin Wang, and Yu Qiao. 2023c.  Videochat: Chat-centric video understanding.  _arXiv preprint arXiv:2305.06355_.
  * Li et al. (2023d) Xingxuan Li, Ruochen Zhao, Yew Ken Chia, Bosheng Ding, Lidong Bing, Shafiq Joty, and Soujanya Poria. 2023d.  Chain of knowledge: A framework for grounding large language models with structured knowledge bases.  _arXiv preprint arXiv:2305.13269_.
  * Li et al. (2023e) Yifan Li, Yifan Du, Kun Zhou, Jinpeng Wang, Wayne Xin Zhao, and Ji-Rong Wen. 2023e.  Evaluating object hallucination in large vision-language models.  _arXiv preprint arXiv:2305.10355_.
  * Lin et al. (2014) Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollár, and C Lawrence Zitnick. 2014.  Microsoft coco: Common objects in context.  In _Computer Vision–ECCV 2014: 13th European Conference, Zurich, Switzerland, September 6-12, 2014, Proceedings, Part V 13_ , pages 740–755. Springer.
  * Liu and Wan (2023) Hui Liu and Xiaojun Wan. 2023.  Models see hallucinations: Evaluating the factuality in video captioning.  _arXiv preprint arXiv:2303.02961_.
  * Luo et al. (2023) Junyu Luo, Cao Xiao, and Fenglong Ma. 2023.  Zero-resource hallucination prevention for large language models.  _arXiv preprint arXiv:2309.02654_.
  * Manakul et al. (2023) Potsawee Manakul, Adian Liusie, and Mark J. F. Gales. 2023.  Selfcheckgpt: Zero-resource black-box hallucination detection for generative large language models.
  * McKenna et al. (2023) Nick McKenna, Tianyi Li, Liang Cheng, Mohammad Javad Hosseini, Mark Johnson, and Mark Steedman. 2023.  Sources of hallucination by large language models on inference tasks.  _arXiv preprint arXiv:2305.14552_.
  * Mündler et al. (2023) Niels Mündler, Jingxuan He, Slobodan Jenko, and Martin Vechev. 2023.  Self-contradictory hallucinations of large language models: Evaluation, detection and mitigation.
  * Peng et al. (2023) Baolin Peng, Michel Galley, Pengcheng He, Hao Cheng, Yujia Xie, Yu Hu, Qiuyuan Huang, Lars Liden, Zhou Yu, Weizhu Chen, et al. 2023.  Check your facts and try again: Improving large language models with external knowledge and automated feedback.  _arXiv preprint arXiv:2302.12813_.
  * Pfeiffer et al. (2023) Jonas Pfeiffer, Francesco Piccinno, Massimo Nicosia, Xinyi Wang, Machel Reid, and Sebastian Ruder. 2023.  mmt5: Modular multilingual pre-training solves source language hallucinations.
  * Rohrbach et al. (2018) Anna Rohrbach, Lisa Anne Hendricks, Kaylee Burns, Trevor Darrell, and Kate Saenko. 2018.  Object hallucination in image captioning.  _arXiv preprint arXiv:1809.02156_.
  * Rombach et al. (2022) Robin Rombach, Andreas Blattmann, Dominik Lorenz, Patrick Esser, and Björn Ommer. 2022.  High-resolution image synthesis with latent diffusion models.  In _Proceedings of the IEEE/CVF conference on computer vision and pattern recognition_ , pages 10684–10695.
  * Umapathi et al. (2023) Logesh Kumar Umapathi, Ankit Pal, and Malaikannan Sankarasubbu. 2023.  Med-halt: Medical domain hallucination test for large language models.  _arXiv preprint arXiv:2307.15343_.
  * Varshney et al. (2023) Neeraj Varshney, Wenlin Yao, Hongming Zhang, Jianshu Chen, and Dong Yu. 2023.  A stitch in time saves nine: Detecting and mitigating hallucinations of llms by validating low-confidence generation.  _arXiv preprint arXiv:2307.03987_.
  * Wiggers (2023) Kyle Wiggers. 2023.  Are ai models doomed to always hallucinate?
  * Wu et al. (2023) Jing Wu, Jennifer Hobbs, and Naira Hovakimyan. 2023.  Hallucination improves the performance of unsupervised visual representation learning.  _arXiv preprint arXiv:2307.12168_.
  * Yu et al. (2023) Yongsheng Yu, Heng Fan, and Libo Zhang. 2023.  Deficiency-aware masked transformer for video inpainting.  _arXiv preprint arXiv:2307.08629_.
  * Zhang et al. (2023a) Muru Zhang, Ofir Press, William Merrill, Alisa Liu, and Noah A. Smith. 2023a.  How language model hallucinations can snowball.
  * Zhang et al. (2023b) Shuo Zhang, Liangming Pan, Junzhou Zhao, and William Yang Wang. 2023b.  Mitigating language model hallucination with interactive question-knowledge alignment.
  * Zhang et al. (2023c) Yue Zhang, Yafu Li, Leyang Cui, Deng Cai, Lemao Liu, Tingchen Fu, Xinting Huang, Enbo Zhao, Yu Zhang, Yulong Chen, et al. 2023c.  Siren’s song in the ai ocean: A survey on hallucination in large language models.  _arXiv preprint arXiv:2309.01219_.


# SPIDER: Searching Personalized Neural Architecture for Federated Learning

Erum Mushtaq 1, Chaoyang He 1, Jie Ding 2, Salman Avestimehr 1
Erum Mushtaq
University of Southern California
<EMAIL_ADDRESS>Chaoyang He
University of Southern California
<EMAIL_ADDRESS>Jie Ding
University of Minnesota
<EMAIL_ADDRESS>Salman Avestimehr
University of Southern California
<EMAIL_ADDRESS>
###### Abstract

Federated learning (FL) is an efficient learning framework that assists
distributed machine learning when data cannot be shared with a centralized
server due to privacy and regulatory restrictions. Recent advancements in FL
use predefined architecture-based learning for all the clients. However, given
that clients’ data are invisible to the server and data distributions are non-
identical across clients, a predefined architecture discovered in a
centralized setting may not be an optimal solution for all the clients in FL.
Motivated by this challenge, in this work, we introduce SPIDER, an algorithmic
framework that aims to Search PersonalIzed neural architecture for feDERated
learning. SPIDER is designed based on two unique features: (1) alternately
optimizing one architecture-homogeneous global model (Supernet) in a generic
FL manner and one architecture-heterogeneous local model that is connected to
the global model by weight sharing-based regularization (2) achieving
architecture-heterogeneous local model by a novel neural architecture search
(NAS) method that can select optimal subnet progressively using operation-
level perturbation on the accuracy value as the criterion. Experimental
results demonstrate that SPIDER outperforms other state-of-the-art
personalization methods, and the searched personalized architectures are more
inference efficient.

##  1 Introduction

Federated Learning (FL) is a promising decentralized machine learning
framework that facilitates data privacy and low communication costs. It has
been extensively explored in various machine learning domains such as computer
vision, natural language processing, and data mining. Despite many benefits of
FL, one major challenge involved in FL is data heterogeneity, meaning that the
data distributions across clients are not identically or independently
(non-I.I.D) distributed. The non-I.I.D distributions result in the varying
performance of a globally learned model across different clients. In addition
to data heterogeneity, data invisibility is another challenge in FL. Since
clients’ private data remain invisible to the server, from the server’s
perspective, it is unclear how to select a pre-defined architecture from a
pool of all available candidates. In practice, it may require extensive
experiments and hyper-parameter tuning over different architectures, a
procedure that can be prohibitively expensive.

To address the data-heterogeneity challenge, variants of the standard FedAvg
have been proposed to train a global model, including the FedProx [17], FedOPT
[23], and FedNova [31]. In addition to training of a global model, frameworks
that focus on training personalized models have also gained a lot of
popularity. The Ditto [16], PerFedAvg [4], and pFedMe [3] are some of the
recent works that have shown promising results to obtain improved performance
across clients. However, all these works exploit pre-defined architectures and
operate at the optimization layer. Consequently, in addition to their inherent
hyper-parameters tuning, these personalization frameworks often encounter the
data-invisibility challenge that one has to select a suitable model
architecture involving a lot of hyper-parameter tuning.

In this work, we adopt a different and complementary technique to address the
data heterogeneity challenge for FL. We introduce SPIDER, an algorithmic
framework that aims to Search PersonalIzed neural architecture for feDERated
learning. Recall that in a centralized setting, the neural architecture search
(NAS) aims to search for optimal architecture to address system design
challenges such as lower latency [34], lesser memory cost [15], and smaller
energy consumption [36]. For architecture search, there are three well known
methods explored in literature, gradient-based [21], evolutionary search [22],
and reinforcement learning [12]. Out of these, gradient-based methods are
generally considered more efficient because of their ability to yield higher
performance in comparatively lesser time [25].

To achieve personalization at the architecture level in FL, we propose a
unified framework, SPIDER. This framework essentially deploys two models,
local and global models, on each client. Initially, both models use the DARTS
search space-based Supernet [21], an over-parameterized architecture. In the
proposed framework, the global model is shared with the server for the FL
updates and, therefore, stays the same in the architecture design. On the
other hand, the local model stays completely private and performs personalized
architecture search, therefore, gets updated. To search for the personalized
child model, SPIDER deploys SPIDER-Searcher on each client’s local model. The
SPIDER-Searcher is built upon a well-known gradient-based NAS method, named
perturbation-based NAS [33]. The main objective of the SPIDER framework is to
allow each client to search and optimize their local models while benefiting
from the global model. To achieve this goal, we propose an alternating bi-
level optimization-based SPIDER Trainer that trains local and global models in
an alternate fashion. However, the main challenge here is the optimization of
an evolving local model architecture while benefiting from a fixed global
architecture. To address this challenge, SPIDER Trainer performs weight
sharing-based regularization that regularizes the common connections between
the global model’s Supernet and the local model’s child model. This aids
clients in searching and training heterogeneous architectures tailored for
their local data distributions. In a nutshell, this approach not only yields
architecture personalization in FL but also facilitates model privacy (in the
sense that the derived child local model is not shared with the server at
all).

To evaluate the performance of the proposed algorithm, we consider a cross-
silo FL setting and use Dirichlet distribution to create non-I.I.D data
distribution across clients. For evaluation, we report test accuracy at each
client on the 20% of training data kept as test data for each client. We show
that the architecture personalization yields better results than state-of-the-
art personalization algorithms based solely on the optimization layer, such as
Ditto [16], perFedAvg [4], and local adaptation [1].

To summarize, the following are the key contributions of our work.

$\bullet$ We propose and formulate a personalized neural architecture search
framework for FL named SPIDER, from a perspective complementary to the state-
of-the-arts to address data heterogeneity challenges in FL.

$\bullet$ SPIDER is designed based on two unique features: (1) maintaining two
models at each client, one to communicate with the server and the other to
perform a local progressive search, and (2) operating local search and
training at each client by an alternating bilevel optimization and weight
sharing-based regularization along the FL updates.

$\bullet$ We run extensive experiments to demonstrate the benefit of SPIDER
compared with state-of-the-art personalized FL approaches such as Ditto [16],
perFedAvg [4] and Local Adaptation [1]. In particular, on the CIFAR10 dataset
with heterogeneous distribution, we demonstrate an increase of the average
local accuracy by 2.8%, 1.7%, and 5.5%, over Ditto, PerFedAvg, and Local
Adaption, respectively.

$\bullet$ We also demonstrate that SPIDER learns smaller personalized
architectures of average size around 14MB, which is three times smaller than a
pre-defined architecture Resnet18 (of size 44MB).

##  2 Related works

#### Heterogeneous Neural Architecture for FL

Heterogeneous neural architecture is one way to personalize the model in FL.
For personalization, the primal-dual framework [29], clustering [26], fine-
tuning with transfer learning [37], meta-learning [4], regularization-based
method [7, 16] are among the popular methods explored in the FL literature.
Although these techniques achieve improved personalized performance, all of
them use a pre-defined architecture for each client. HeteroFL [2] is a recent
work that accomplishes the aggregation of heterogeneous models by assigning
sub-parts of the global model based on their computation budget and
aggregating the parameters common between different clients. Another work [19]
accomplishes this task by forming clusters of clients of the same model and
allowing for heterogeneous models across clusters. On the server-side, the
aggregation is based on cluster-wise aggregation followed by a knowledge
distillation from the aggregated models into the global model. Given data
invisibility in FL, deciding which pre-defined architecture would work for
which client is a challenging task and requires exploration. As such, our
proposed method aims to achieve personalized architecture automatically.

#### Neural Architecture Search for FL

Neural Architecture Search (NAS) has gained momentum in recent literature to
search for a global model in a federated setting. FedNAS [8] explores the
compatibility of MileNAS solver with Fed averaging algorithm to search for a
global model. Direct Federated NAS [11] is another work in this direction that
explores the compatibility of a one-shot NAS method, DSNAS [11], with Fed
averaging algorithm with the same application, in search of a global model.
[40] uses evolutionary NAS to design a master (global) model. [28] explores
the concept of differential privacy using DARTs solver [21] to explore the
trade-off between accuracy and privacy of a global model. [35] starts with a
pre-trained handcraft model and continues pruning the model until it satisfies
the efficiency budget. Where all these models search for a unified global
model, a key distinction of our work with these works is that we aim to search
for a personalized model for each client.

##  3 Preliminaries, Motivation, and Design Goals

In this section, we introduce the state-of-the-art methods for personalized
federated learning, discuss the motivation for personalizing model
architectures, and summarize our design goals.

#### Personalized Federated Learning

A natural formulation of FL is to assume that among $K$ distinct clients, each
client $k$ has its own distribution $P_{i}$, draws data observations (samples)
from $P_{i}$, and aims to solve a supervised learning task (e.g., image
classification) by optimizing a global model $w$ with other clients
collaboratively. At a high-level abstraction, the optimization objective is
then defined as:

$\displaystyle\min_{w^{*}}G\left(F_{1}(w),...,F_{K}(w)\right),$ (1)

where $F_{k}(w)$ measures the performance of the model global $w$ on the
private dataset at client $k$ (local objective), and $G$ is the global model
aggregation function that aggregates each client’s local objectives. For
example, for FedAvg, $G(.)$ would be weighted aggregation of the local
objectives, $\sum_{k=1}^{K}p_{k}F_{k}(w)$, where $\sum_{k=1}^{K}p_{k}=1$.

However, as distributions across individual clients are typically
heterogeneous (i.e., non-I.I.D.), there is a growing line of research that
advocates to reformulate FL as a personalization framework, dubbed as
personalized FL (PFL). In PFL, the objective is redirected to find a
personalized model $v_{k}$ for device $k$ that performs well on the local data
distribution:

$\displaystyle\min_{v_{1}^{*},...,v_{K}^{*}}\left(F_{1}(v_{1}),...,F_{K}(v_{K})\right),$
(2)

To solve this challenging problem, various PFL methods are proposed, including
FedAvg with local adaptation (Local-FL) [1, 38, 32], MAML-based PFL (MAML-FL)
[5, 13], clustered FL (CFL) [6, 27], personalized layer-based FL (PL-FL) [18],
federated multitask learning (FMTL) [30], and knowledge distillation (KD) [20,
9].

#### Motivation for Neural Architecture Personalization

Distinct from these existing works on PFL, we propose a new approach to
instead personalize model architecture for each client. We are motivated by
three key potential benefits. First, the searched architecture at each client
is expected to fit its own distinct distribution, which has the potential to
provide a substantial improvement over the existing PFL baselines that only
personalize model weights. Second, a personalized architecture search can
result in a more compressed model for each client that will reduce inference
latency and efficiency. Third, a personalized architecture search allows the
clients to even keep their local model architectures private in a sense the
server and other clients neither know the architecture nor the weights of that
architecture. This further enhances the privacy guarantees of FL and is
helpful in business cases that each client hopes to also protect its model
architecture.

#### Design Goals

Our goal is to enable personalized neural architecture search for all clients
in FL. In this context, the limitation of existing personalized FL methods is
obvious: Local-FL and MAML-FL need every client to have the same architecture
to perform local adaptations; In CFL, the clustering step requires all clients
to share a homogeneous model architecture; PL-FL can only obtain heterogeneous
architectures for a small portion of personalized layers, but it does not
provide an architecture-agnostic method to determine the boundary of
personalized layers in an automated mechanism; FMTL is a regularization-based
method which cannot perform regularization when architectures are
heterogeneous across clients; KD has an unrealistic assumption that the server
has enough public dataset as the auxiliary data for knowledge distillation. In
addition, an ideal FL framework for deployment is the one that can jointly
optimize the inference latency/efficiency during training. However, after
federated training, none of these PFL clearly specify the method for efficient
inference. An additional model compression procedure (e.g., pruning or KD-
based) may be required, but it is impractical to perform a remote model
compression client by client.

To circumvent these limitations, our goal is to design an architecture-
personalized FL framework with the following requirements:

  * •

R1: allowing heterogeneous architectures for all clients, which can capture
fine-grained data heterogeneity;

  * •

R2: searching and personalizing the entire architecture space, to avoid the
heuristic search for the boundary of personalized layers;

  * •

R3: requiring no auxiliary data at the client- or server-side (unlike
knowledge distillation-based PFL);

  * •

R4: resulting in models with practical inference latency and efficiency, to
avoid the need for an additional model compression procedure at each client.

We now introduce SPIDER that meets the above requirements in a unified
framework.

##  4 Methodology: SPIDER

###  4.1 Overview

Figure 1: Illustration of SPIDER framework. SPIDER is weaving (searching) a
different web (neural architecture) for each client.

The overall framework of SPIDER is illustrated in Figure 1. Essentially, each
client maintains two models in this framework: one architecture-homogeneous
global model for collaborative training with other clients, and one
architecture-heterogeneous local model that initially shares the same super
architecture space as the global model. At a high-level, SPIDER is formulated
as an architecture-personalized bi-level optimization problem (Section 4.2)
and proposes the solver as the orchestration of SPIDER Trainer (Section 4.3)
and SPIDER-Searcher (Section 4.4). SPIDER Trainer is an architecture-
personalized training framework that can collaboratively train heterogeneous
neural architectures across clients. To allow federated training on the
expected heterogeneous local architectures, it enables regularization between
an arbitrary personalized architecture and the global model via weight
sharing. With this support, SPIDER-Searcher is designed to dynamically adjust
the architecture of each client’s local model on the way. To search a
personalized architecture for the local data distribution of each client,
SPIDER-Searcher is built on a novel neural architecture search (NAS) method
that searches optimal local Subnet progressively using operation-level
perturbation on the accuracy value as the criterion. Overall, each client’s
local model goes through three phases (also shown in Figure 1): pre-training
to warm up the initial local model, progressive neural architecture search,
and final training of the searched architecture-personalized model.

SPIDER can meet the design goals R1-R4 introduced in Section 3 because 1) each
client performs independent architecture personalization with its own private
data (R1), 2) the search space is not restricted to a portion of the model
(R2), 3) no auxiliary data is used to assist the search and train process
(R3), and 4) progressive operation selection gradually reduces the number of
candidate architectures, leading to a sparse and efficient model for inference
(R4).

###  4.2 SPIDER Formulation: Architecture-personalized Bi-level Optimization

SPIDER aims to personalize (weave) a different neural architecture (web) for
each client. To generate heterogeneous architectures across clients, we use
two models, a local model (${a}_{k}$) and a global model (Supernet
$\mathcal{A}$) at each client, and formulate SPIDER as an architecture-
personalized bi-level optimization problem for each client $k\in[K]$:

$\displaystyle\min_{v_{k},a_{k}\subseteq\mathcal{A}}\quad
F_{k}(v_{k},a_{k};w^{*},\mathcal{A})$ (3) $\displaystyle\text{s.t.}\quad
w^{*}\in\arg\min_{w}G\left(F_{1}(w,\mathcal{A}),...,F_{K}(w,\mathcal{A})\right),$
(4)

where $F_{k}$ is the local objective of the client $k$; $w$, $v_{k}$, and
$a_{k}$ are all learnable parameters; $w$ denotes the parameter of the global
model architecture $\mathcal{A}$, $v_{k}$ is the weight parameter of the local
personalized architecture $a_{k}$ of the client $k$. Here, $a_{k}$ is a child
neural architecture of a Supernet $\mathcal{A}$, denoted by
$a_{k}\subseteq\mathcal{A}$. Note that in Eq.(4), we aim to learn a global
model $\mathcal{A}$ in a federated learning setting, which formulates our
outer optimization. However, in the inner optimization given in Eq.(3), the
objective of each client is to optimize its local model’s architecture $a_{k}$
and its associated parameters $v_{k}$ while benefiting from the global model
$w^{*}$.

#### Definition of Supernet $\mathcal{A}$ and Child Neural Architecture
$a_{k}$

As a tractable, yet general case study, SPIDER reuses the DARTS architecture
space as Supernet $\mathcal{A}$: there are 8 cells, and each cell consists of
multiple edges; each edge connects two intermediate representations (node) by
a mixture of multiple operations frequently used in various modern CNNs (e.g.,
sep convolution 3x3, sep convolution 5x5, dil convolution 3x3, skip
connection, max pool 3x3, avg pool 3x3); the mixture uses softmax over all
possible operations to relax the categorical discrete candidate to a
continuous search space. More precisely, $\mathcal{A}$ contains a set of edges
${\\{e_{1},...,e_{E}\\}}$, and each edge $e$ has multiple operations
${\\{o_{1},...,o_{O}\\}}$. Based on this definition, $a_{k}$ maintains the
operation-level granularity: $a_{k}$’s edge set space is a subset of
$\mathcal{A}$’s edge set space, and the operation set in $a_{k}$’s each edge
may also be a subset space.

#### The difficulty of jointly optimizing the architecture $a_{k}$ and related
weight parameters $v_{k}$

The key difference of our formulation from existing bi-level optimization for
FL (e.g., [16]) is that in our case, $a_{k}$ is also a learnable parameter
(Eq.(3)). We assume each client can have an evolving architecture $a_{k}$,
i.e., Eq.(3) has to optimize the architecture $a_{k}$ and its related weight
parameters $v_{k}$ jointly, while using complete Supernet-based global model
weights, $w$. SPIDER addresses this challenge by the orchestration of SPIDER-
Trainer and SPIDER-Searcher.

###  4.3 SPIDER Trainer: Federated Training on Heterogeneous Architectures

In this section, we describe SPIDER trainer, an architecture-personalized
training framework that can collaboratively train heterogeneous neural
architectures across clients.

To clearly show how SPIDER handles the optimization difficulty of Eq.(3), we
first downgrade the objective to the case that all clients use predefined
(fixed) heterogeneous architectures (derived from the Supernet $\mathcal{A}$).
More specially, we reduce the aforementioned optimization framework in Eq.(3)
and Eq.(4) to the following:

$\displaystyle\min_{v_{k}}$ $\displaystyle\quad
h_{k}(v_{k},a_{k};w^{*},\mathcal{A})=F_{k}(v_{k})+\frac{\lambda}{2}||v_{k}-w_{share}^{*}||^{2}$
(5) s.t. $\displaystyle\quad
w^{*}\in\arg\min_{w}G\left(F_{1}(w,\mathcal{A}),...,F_{K}(w,\mathcal{A})\right),$
(6)

where local model’s weights $v_{k}$ are regularized towards the global model
$w^{*}_{share}$, where $w^{*}_{share}=w^{*}\odot a_{k}$ (i.e., only using the
weight parameters of the operation set space overlapping (sharing) with
$a_{k}$). Also, $\lambda$ is the regularization hyper-parameter. Note that,
now, only $v_{k}$ needs to be optimized in Eq.5, while $a_{k}$ is fixed during
the optimization.

We then solve Eq.5 and Eq.6 alternately. We summarize this optimization
procedure as SPIDER-Trainer with a detailed pseudo code illustrated in
Algorithm 1. In this algorithm, we can note that the global model (line #12)
and the local model (line #14) are updated alternately. The strength of this
algorithm lies in its elaborate design, which provides the following key
benefits:

Algorithm 1 SPIDER Trainer

1: Initialization: initialize $K$ clients with the $k$-th client has a global
model $w_{k}$ using Supernet $\mathcal{A}$, and a local model ${v_{k}}$ using
subnet $a_{k}$ (set $a_{k}=\mathcal{A}$ at the begining); $E$ is the number of
local epochs; $T$ is the number of rounds; $T_{s}$ number of rounds to start
search; $\tau$ is the recovery periods in the units of rounds.

2: Server executes:

3: for each round $t=0,1,2,...,T-1$ do

4: for each client $k$ in parallel do

5: $w_{k}^{t+1}\leftarrow\text{ClientLocalSearch}(k,w^{t},t)$

6: $w^{t+1}\leftarrow\sum_{k=1}^{K}\frac{N_{k}}{N}w_{k}^{t+1}$

7:

8: function ClientLocalSearch($k$, $w^{t}$, $t$): // Run on client $k$

9: for $e$ in epoch do

10: for minibatch in training and validation data do

11: $a_{k}^{t}=\textbf{ProgressiveNAS}(a_{k}^{t},T_{s},\tau,t)$

12: Update Global model:
$w^{t+1}=w^{t}-\eta_{w}\nabla_{w}F_{k}^{\mathrm{tr}}(w^{t})$

13: $w^{t+1}_{share}=w^{t+1}\odot a_{k}^{t}\text{ //weight sharing}$

14: Update Local Model: $\text{
}v_{k}^{t+1}=v_{k}^{t}-\eta_{v}\left(\nabla_{v}F_{k}^{\mathrm{tr}}(v_{k}^{t})+\lambda(v_{k}^{t}-w^{t+1}_{share})\right)$

15: return $w$ to server

#### (1) Enabling regularization between an arbitrary personalized
architecture and the global model

Most importantly, SPIDER-Trainer connects each personalized model with the
global model by enabling the regularization between two different
architectures: an arbitrary personalized architecture for the local model
$a_{k}$ of client $k$ and the global model with Supernet $\mathcal{A}$. This
is done by weight sharing. More specially, in Eq.6, $w^{*}_{share}=w^{*}\odot
a_{k}$, which provides us the global model’s weight parameters for the
connections/edges common between the child neural architecture $a_{k}$ and the
global model’s Supernet $\mathcal{A}$. $w^{*}_{share}$ is essentially used to
regularize a subnet ($a_{k}$) model parameters $v_{k}$ towards the global
model shared/common parameters $w^{*}_{share}$, as shown in Eq. 6.

#### (2) Avoiding heterogeneous aggregation

SPIDER-Trainer avoids the aggregation of heterogeneous model architectures at
the server side. As such, no sophisticated and unstable aggregation methods
are required (e.g., masking, knowledge distillation [20], etc.), and it is
flexible to use other aggregation methods beyond FedAvg (e.g., [14, 24]) to
update the global model.

#### (3) Enabling architecture privacy

In this algorithm, only the global model is transmitted between the client and
the server. This enables architecture privacy because each client’s
architecture is hidden from server and other clients.

#### (4) Potential robustness to adversarial attacks

The weight sharing-based regularization not only yields the benefit of
personalization in FL, but also makes the FL framework more robust to
adversarial attacks. Its robustness advantage comes from its ability to keep
the local model private and regularizing towards the global model based on its
regularization parameter, as shown before by architecture-homogeneous bi-level
optimization [16].

###  4.4 SPIDER-Searcher: Personalizing Architecture

Although SPIDER trainer is able to collaboratively train heterogeneous
architectures, manual design of the architecture for each client is
impractical or suboptimal. As such, we further add a neural architecture
search (NAS) component, SPIDER-Searcher, in Algorithm 1 (line #11) to adapt
$a_{k}$ to its local data distribution in a progressive manner. We now present
the details of SPIDER-Searcher.

#### Progressive Neural Architecture Search

Essentially, SPIDER-Searcher dynamically changes the architecture of $a_{k}$
during the entire federated training process. This is feasible because the
weight sharing-based regularization can handle an arbitrary personalized
architecture (introduced in Section 4.3). Due to this characteristic, SPIDER-
Searcher can search $a_{k}$ in a progressive manner (shown in Figure 1): Phase
1: At the beginning, $a_{k}$ is set equal to Supernet $\mathcal{A}$. The
intention of SPIDER-Searcher in this phase is to warm up the training of the
initial $a_{k}$ so it does not change $a_{k}$ for a few rounds; Phase 2: After
warming up, SPIDER-Searcher performs edge-by-edge search gradually. In each
edge search, only the operation with the highest impact to the accuracy is
kept. It also uses a few rounds of training as a recovery time before
proceeding the next round of search. This process continues until all edges
finish searching; Phase 3: After all edges finish searching, SPIDER-Searcher
does not change $a_{k}$. This serves as a final training of the searched
architecture-personalized model. This three-phase procedure is summarized as
Algorithm 2. Now, we proceed to elaborate how we calculate the impact of an
operation on the Supernet.

Algorithm 2 SPIDER-Searcher

1: Search Space: in the architecture $a_{k}^{t}\subseteq\mathcal{A}$,
$\mathcal{E}$ is the super set of all edges ${\\{e_{1},...,e_{E}\\}}$,
$\mathcal{E}_{s}$ is the remaining subset of edges that have not been
searched, and each edge $e$ has multiple operations ${\\{o_{1},...,o_{O}\\}}$.

2: function ProgressiveNAS($a_{k}$, $T_{s}$, $\tau$, t)

3: if $t$ $\geq$ $T_{s}$ and $t$ % $\tau$ == 0 and LEN($\mathcal{E}_{s}$) $>$
$0$ then

4: $e_{i}$ = RANDOM ($\mathcal{E}$)  // random selection

5: // searching without training

6: for all operation $o_{j}$ on edge $e_{i}$ do

7: evaluate validation accuracy of $a_{k}^{t}$ when $o_{j}$ is
removed$(ACC_{\setminus o})$

8: in $e_{i}$, keep only one operation corresponding to the lowest value of
$(ACC_{\setminus o})$, i.e., highest impact.

9: remove $e_{i}$ from $\mathcal{E}$

10: else

11: return $a_{k}^{t}$ directly

12: return updated $a_{k}^{t}$ after selection

#### Operation-level perturbation-based selection

In phase 2, we specify selecting the operation with the highest impact using
operation-level perturbation. More specially, instead of optimizing the mixed
operation architecture parameters $\alpha$ using another bi-level optimization
as DARTS (a.k.a. gradient-based search) to pick optimal operation according to
magnitude of $\alpha$ parameters (magnitude-based selection), we fix a uniform
distribution for $\alpha$ and use the impact of an operation on the local
validation accuracy (perturbation) as a criterion to search on the edge. This
simplified method is much more efficient given that it only requires
evaluation-based search rather than training-based search (optimizing
$\alpha$). In addition, it avoids inserting another bi-level optimization for
NAS inside a bi-level optimization for FL, making the framework stable and
easy to tune. Finally, this method avoids suboptimal architecture [33] lead by
magnitude-based selection in differentiable NAS.

##  5 Experiments

This section presents the experimental results of the proposed method, SPIDER.
All our experiments are based on a non-IID data distribution among FL clients.
We have used latent Dirichlet Distribution (LDA), which is a common data
distribution in FL to generate non-IID data across clients [10], [39].

###  5.1 Experimental Setup

#### Implementation and Deployment

We implement the proposed method for distributed computing with nine nodes,
each equipped with GPUs. We set this as a cross-silo FL setting with one node
representing the server and eight nodes representing the clients. These
clients nodes can represent real-world organizations such as hospitals and
clinics that aim to collaboratively search for personalized architectures for
local benefits in a privacy-preserving FL manner.

(a) Label distribution per client

(b) Image distribution per client

Figure 2: CIFAR10: LDA distribution

(a) Average Validation Accuracy comparison

(b) Architecture search vs. Architecture train Phase

Figure 3: Comparison of our proposed method, SPIDER, with other state-of-the-
art personalization methods (perFedAvg, Ditto, and local adaptation). The left
figure shows the average validation accuracy comparison between our proposed
method SPIDER and the other state-of-the-art methods; perFedAvg, Ditto, and
local adaptation. The right figure illustrates the architecture search
(progressive perturbation of the Supernet) and derived child model’s
architecture train phase of the proposed method.

(a) Average Validation Accuracy per client

(b) Average Validation Accuracy distribution

(c) Accuracy improvement of SPIDER

Figure 4:  Validation Accuracy Analysis

#### Task and Dataset

We perform an image classification task on the CIFAR10 dataset that consists
of 60000 32x32 color images in 10 classes, with 6000 images per class. We
generate non-IID data across clients by exploiting LDA distribution with
parameter $(\alpha=0.2)$ for the training data of CIFAR10. The actual data
distribution has been shown in figure 9. Sub-figure 2(a) represents the label
distribution across clients, where a darker color indicates more images of
that class/label. The other sub-figure 2(b) represents the total number of
data samples preset at each client. We explore other datasets in the Appendix
D.

For personalized architecture experiments with SPIDER, we split the total
training data samples present at each client into training (50%), validation
(30%), and testing sets (20%). For other personalization schemes used for
comparison, we do not need validation data. Therefore, we split the data
samples of each client with training (80%) and test (20%) for a fair
comparison. In addition, we fix the non-IID dataset distribution in all
experiments for a fair comparison. We provide Hyperparameter search details in
Appendix B.

Table 1: Average local validation Accuracy Comparison of Personalized
Federated NAS with other personalization techniques

Method | Average Accuracy | Parameter Size | FLOPs | Estimated Model Size
---|---|---|---|---
Local Adapation - Supernet | 0.95±0.01 | 1.9M | 319M | 104MB
SPIDER | 0.92±0.02 | 345K | 62M | 14MB
Local Adaptation - ResNet18 | 0.87±0.02 | 11M | 76M | 44MB
Ditto - ResNet18 | 0.90±0.03 | 11M | 76M | 44MB
perFedAvg - ResNet18 | 0.91±0.02 | 11M | 76M | 44MB

###  5.2 Results on Average Validation Accuracy

Here, we report the comparison of our proposed method SPIDER with the other
state-of-the-art personalized methods; Ditto, perFedAvg, and local adaptation.
Since these schemes use a pre-defined architecture, we use the Reset18 model
because of its comparable model size. We also explore local adaptation with
the complete Supernet. This exploration will help us investigate how much
performance drop we get if we use a smaller but personalized model compared
with a locally adapted complete Supernet.

Average Accuracy In Figure 3(b), we report average of the validation accuracy
calculated on client’s test dataset using the personalized architectures
(architecture visualizations provided in Appendix C.1). The right sub-figure
in Fig. 3(b) illustrates the comparison of the proposed method with the state-
of-art methods; Ditto, local adaptation, and perFedAvg. We note that local
adaptation with Supernet provides the highest average accuracy. We expect it
from the Supernet because of its 7 operations-based mixed operation
formulations. This result helps us investigate the performance reduction with
our proposed method. We observe that our proposed method shows a performance
reduction of 2.7% in average validation accuracy with the benefit of a reduced
average number of FLOPs and model size. The models we use during training are
much smaller and require less memory as well as computation.

From empirical results, we observe that the proposed approach of architecture
personalization outperforms the other state-of-the-art personalization
methods; Ditto, perFedAvg, and local adaptation. Among these personalization
schemes, perFedAvg yields the highest performance. Although in Figure 3(b) the
performance curve is lower, it gains 90.9% accuracy around 1500 rounds. We
have added its accuracy plot for 1500 rounds in Appendix C.2. Compared with
perFedAvg, we obtain 1.4% higher average accuracy. Moreover, Ditto and local
adaptation yield a 90% and 87% average accuracy, respectively.

We also analyze the performance of these methods on a client basis. We plot
validation accuracy of each client, accuracy distribution of each method, and
accuracy improvement of the proposed method SPIDER with the other
personalization methods in Figure 4. In the first sub-figure, we observe that
out of 8 total clients, our method yields higher accuracy for 7 clients. For
the other one clients (client number 0), perFedAvg outperforms our method,
respectively. In the second sub-figure, we plot accuracy distribution. The
motivation behind this plot is to observe the standard deviation of these
methods and their concentration of accuracy values. We note that SPIDER
dominates the right side, higher accuracy region, and it has almost the same
spread as perFedAvg and local adaptation baselines.

The third sub-figure illustrates the accuracy improvement, subtraction of the
proposed method’s accuracy values from the other personalized methods on a
client-basis. In comparison to perFedAvg, for 4 client, the accuracy
improvement with the proposed method is within 0-2.5% region, and for 3
clients, it is between 2.5-5% regions. There is only one client for which
perFedAvg outperforms our method in the region of 2.5-5%. For the rest of the
methods, our method yields higher performance for all the clients.

For personalization, in addition to average accuracy, the standard deviation
(std) is considered an important metric. Therefore, we also report the
standard deviation for each method in Table 2. Besides the local adaptation
with Supernet that yields 0.01 standard deviation, our method yields 0.02 std,
which is the same for the other two personalization baselines; PerFedAvg and
local adaptation (resnet18). However, Ditto has the highest deviation (0.03)
among clients. Although we achieve the same standard deviation as other
baselines but with the benefit of providing higher average validation
accuracy.

###  5.3 Results on Efficiency

#### Average FLOPs

In Figure 3(b), we report average flops to gauge the architecture search and
train phase. Following Algorithm 1, Phase 1 continues for 60 rounds, Phase 2
for another 260 rounds, Phase 3 for the next 680 rounds. We used a recovery
time of around 20 rounds. In centralized perturbation-based NAS [33], it was
empirically found that 5 epochs are sufficient for fine-tuning the Supernet.
However, from empirical results in FL, we found 20-30 communication rounds to
be a reasonable number of rounds for recovery. The Average FLOPs vs. number of
rounds figure illustrates the reduction in the size of computations as the
search proceeds. The reduction in the average size of computations has been
from 319M to 62M. However, for the local adaptation, the average FLOPs remain
the same. Likewise, the average parameter size drops from 1.9M to 345K.

#### Model Size

Estimated model size includes the memory size of a forward pass and parameter
size of that model. It essentially corresponds to how much memory a trained
model with trained weights would occupy to obtain inference. Supernet takes
the highest amount of space, 104MB, ResNet18 takes 44MB, and the average model
size from our proposed method occupies 14MB space. The reason we report this
number is that even if Supernet has less parameter size, 1.9M (due to many
non-parameterized operations, i.e., skip connection, max pool, avg pool), it
requires a vast number of FLOPs to compute mixed operations on the feature
maps of all the operations used in our search space. Therefore, the estimated
model size can better represent the actual memory/compute of these models.
Since we are working on a cross-silo setting, search cost (two models on each
client) may not be a concern since devices in cross-silo are rich in
resources. However, the proposed search yields architectures that are smaller
in size and inference efficient, which can be beneficial for many business
models.

##  6 Conclusion

We proposed SPIDER, an algorithmic framework that can search personalized
neural architecture for FL. SPIDER specializes a weight-sharing-based global
regularization to perform progressive neural architecture search. Experimental
results demonstrate that SPIDER outperforms other state-of-the-art
personalization methods, and the searched personalized architectures are more
inference efficient.

## References

  * [1] Gary Cheng, Karan N. Chadha, and John C. Duchi.  Fine-tuning in federated learning: a simple but tough-to-beat baseline.  2021\.
  * [2] Enmao Diao, Jie Ding, and Vahid Tarokh.  Heterofl: Computation and communication efficient federated learning for heterogeneous clients.  arXiv preprint arXiv:2010.01264, 2020.
  * [3] Canh T Dinh, Nguyen H Tran, and Tuan Dung Nguyen.  Personalized federated learning with moreau envelopes.  arXiv preprint arXiv:2006.08848, 2020.
  * [4] Alireza Fallah, Aryan Mokhtari, and Asuman Ozdaglar.  Personalized federated learning: A meta-learning approach.  arXiv preprint arXiv:2002.07948, 2020.
  * [5] Alireza Fallah, Aryan Mokhtari, and Asuman E. Ozdaglar.  Personalized federated learning: A meta-learning approach.  ArXiv, abs/2002.07948, 2020.
  * [6] Avishek Ghosh, Jichan Chung, Dong Yin, and Kannan Ramchandran.  An efficient framework for clustered federated learning.  ArXiv, abs/2006.04088, 2020.
  * [7] Filip Hanzely and Peter Richtárik.  Federated learning of a mixture of global and local models.  arXiv preprint arXiv:2002.05516, 2020.
  * [8] Chaoyang He, Murali Annavaram, and Salman Avestimehr.  Fednas: Federated deep learning via neural architecture search.  arXiv e-prints, pages arXiv–2004, 2020.
  * [9] Chaoyang He, Murali Annavaram, and Salman Avestimehr.  Group knowledge transfer: Federated learning of large cnns at the edge.  arXiv: Learning, 2020.
  * [10] Chaoyang He, Songze Li, Jinhyun So, Xiao Zeng, Mi Zhang, Hongyi Wang, Xiaoyang Wang, Praneeth Vepakomma, Abhishek Singh, Hang Qiu, et al.  Fedml: A research library and benchmark for federated machine learning.  arXiv preprint arXiv:2007.13518, 2020.
  * [11] Shoukang Hu, Sirui Xie, Hehui Zheng, Chunxiao Liu, Jianping Shi, Xunying Liu, and Dahua Lin.  Dsnas: Direct neural architecture search without parameter retraining.  In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 12084–12092, 2020.
  * [12] Yesmina Jaafra, Jean Luc Laurent, Aline Deruyver, and Mohamed Saber Naceur.  Reinforcement learning for neural architecture search: A review.  Image and Vision Computing, 89:57–66, 2019.
  * [13] Yihan Jiang, Jakub Konecný, Keith Rush, and Sreeram Kannan.  Improving federated learning personalization via model agnostic meta learning.  ArXiv, abs/1909.12488, 2019.
  * [14] Sai Praneeth Karimireddy, Satyen Kale, Mehryar Mohri, Sashank J. Reddi, Sebastian U. Stich, and Ananda Theertha Suresh.  Scaffold: Stochastic controlled averaging for federated learning.  In ICML, 2020.
  * [15] Chaojian Li, Zhongzhi Yu, Yonggan Fu, Yongan Zhang, Yang Zhao, Haoran You, Qixuan Yu, Yue Wang, and Yingyan Lin.  Hw-nas-bench: Hardware-aware neural architecture search benchmark.  arXiv preprint arXiv:2103.10584, 2021.
  * [16] Tian Li, Shengyuan Hu, Ahmad Beirami, and Virginia Smith.  Ditto: Fair and robust federated learning through personalization.  In International Conference on Machine Learning, pages 6357–6368. PMLR, 2021.
  * [17] Tian Li, Anit Kumar Sahu, Manzil Zaheer, Maziar Sanjabi, Ameet Talwalkar, and Virginia Smith.  Federated optimization in heterogeneous networks.  arXiv preprint arXiv:1812.06127, 2018.
  * [18] Paul Pu Liang, Terrance Liu, Liu Ziyin, Ruslan Salakhutdinov, and Louis-Philippe Morency.  Think locally, act globally: Federated learning with local and global representations.  ArXiv, abs/2001.01523, 2020.
  * [19] Tao Lin, Lingjing Kong, Sebastian U Stich, and Martin Jaggi.  Ensemble distillation for robust model fusion in federated learning.  arXiv preprint arXiv:2006.07242, 2020.
  * [20] Tao Lin, Lingjing Kong, Sebastian U. Stich, and Martin Jaggi.  Ensemble distillation for robust model fusion in federated learning.  ArXiv, abs/2006.07242, 2020.
  * [21] Hanxiao Liu, Karen Simonyan, and Yiming Yang.  Darts: Differentiable architecture search.  arXiv preprint arXiv:1806.09055, 2018.
  * [22] Yuqiao Liu, Yanan Sun, Bing Xue, Mengjie Zhang, Gary G Yen, and Kay Chen Tan.  A survey on evolutionary neural architecture search.  IEEE Transactions on Neural Networks and Learning Systems, 2021\.
  * [23] Sashank Reddi, Zachary Charles, Manzil Zaheer, Zachary Garrett, Keith Rush, Jakub Konečnỳ, Sanjiv Kumar, and H Brendan McMahan.  Adaptive federated optimization.  arXiv preprint arXiv:2003.00295, 2020.
  * [24] Sashank J. Reddi, Zachary B. Charles, Manzil Zaheer, Zachary Garrett, Keith Rush, Jakub Konecný, Sanjiv Kumar, and H. Brendan McMahan.  Adaptive federated optimization.  ArXiv, abs/2003.00295, 2021.
  * [25] Santanu Santra, Jun-Wei Hsieh, and Chi-Fang Lin.  Gradient descent effects on differential neural architecture search: A survey.  IEEE Access, 9:89602–89618, 2021.
  * [26] Felix Sattler, Klaus-Robert Müller, and Wojciech Samek.  Clustered federated learning: Model-agnostic distributed multitask optimization under privacy constraints.  IEEE transactions on neural networks and learning systems, 2020\.
  * [27] Felix Sattler, Klaus-Robert Müller, and Wojciech Samek.  Clustered federated learning: Model-agnostic distributed multitask optimization under privacy constraints.  IEEE Transactions on Neural Networks and Learning Systems, 32:3710–3722, 2021.
  * [28] Ishika Singh, Haoyi Zhou, Kunlin Yang, Meng Ding, Bill Lin, and Pengtao Xie.  Differentially-private federated neural architecture search.  arXiv preprint arXiv:2006.10559, 2020.
  * [29] Virginia Smith, Chao-Kai Chiang, Maziar Sanjabi, and Ameet Talwalkar.  Federated multi-task learning.  arXiv preprint arXiv:1705.10467, 2017.
  * [30] Virginia Smith, Chao-Kai Chiang, Maziar Sanjabi, and Ameet S. Talwalkar.  Federated multi-task learning.  In NIPS, 2017.
  * [31] Jianyu Wang, Qinghua Liu, Hao Liang, Gauri Joshi, and H Vincent Poor.  Tackling the objective inconsistency problem in heterogeneous federated optimization.  arXiv preprint arXiv:2007.07481, 2020.
  * [32] Kangkang Wang, Rajiv Mathews, Chloé Kiddon, Hubert Eichner, Franccoise Beaufays, and Daniel Ramage.  Federated evaluation of on-device personalization.  ArXiv, abs/1910.10252, 2019.
  * [33] Ruochen Wang, Minhao Cheng, Xiangning Chen, Xiaocheng Tang, and Cho-Jui Hsieh.  Rethinking architecture selection in differentiable nas.  arXiv preprint arXiv:2108.04392, 2021.
  * [34] Bichen Wu, Xiaoliang Dai, Peizhao Zhang, Yanghan Wang, Fei Sun, Yiming Wu, Yuandong Tian, Peter Vajda, Yangqing Jia, and Kurt Keutzer.  Fbnet: Hardware-aware efficient convnet design via differentiable neural architecture search.  In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 10734–10742, 2019.
  * [35] Mengwei Xu, Yuxin Zhao, Kaigui Bian, Gang Huang, Qiaozhu Mei, and Xuanzhe Liu.  Federated neural architecture search.  arXiv preprint arXiv:2002.06352, 2020.
  * [36] Lei Yang, Zheyu Yan, Meng Li, Hyoukjun Kwon, Liangzhen Lai, Tushar Krishna, Vikas Chandra, Weiwen Jiang, and Yiyu Shi.  Co-exploration of neural architectures and heterogeneous asic accelerator designs targeting multiple tasks.  In 2020 57th ACM/IEEE Design Automation Conference (DAC), pages 1–6. IEEE, 2020.
  * [37] Tao Yu, Eugene Bagdasaryan, and Vitaly Shmatikov.  Salvaging federated learning by local adaptation.  arXiv preprint arXiv:2002.04758, 2020.
  * [38] Tao Yu, Eugene Bagdasaryan, and Vitaly Shmatikov.  Salvaging federated learning by local adaptation.  ArXiv, abs/2002.04758, 2020.
  * [39] Mikhail Yurochkin, Mayank Agarwal, Soumya Ghosh, Kristjan Greenewald, Nghia Hoang, and Yasaman Khazaeni.  Bayesian nonparametric federated learning of neural networks.  In International Conference on Machine Learning, pages 7252–7261. PMLR, 2019.
  * [40] Hangyu Zhu and Yaochu Jin.  Real-time federated evolutionary neural architecture search.  IEEE Transactions on Evolutionary Computation, 2021.

Appendix

##  Appendix A Search Space

As mentioned in Section 4.2, we have used DARTs search space [21] in our
proposed work. During the search, we are using a total of 8 cells. In this
search space, there are two types of cells, normal cell, and reduction cell.
For the Supernet $\mathcal{A}$ construction, there are two normal cells
accompanied by one reduction cell and so on, as shown in Figure 5. In our
construction, the reduction cell is used at positions 3 and 6, and at the
remaining positions, 1,2,4,5,7,8, normal cell is placed. Furthermore, when we
perform perturbation, we perturb both of the cells, normal and reduction
cells, one by one at that particular communication round. In addition, the
same cells follow the same construction; therefore, if one operation is
selected for one normal cell at a particular edge, the same operation will be
selected for the same edge at all normal cells.

Figure 5: Supernet $\mathcal{A}$ search space. Note that since we have 8 cell
based search space, N = 2 for our construction.

##  Appendix B Hyperparameters

###  B.1 Hyper-parameters for CIFAR10.

For empirical results of CIFAR10, we use a batch size of 32 for all our
experiments. Furthermore, we use a learning rate in the search range of
$\\{0.1,0.3,0.01,0.01\\}$ for SPIDER and local adaptation with Supernet. For
SPIDER, we used $\lambda$ search from the set of $\\{0.01,0.1,1\\}$. For the
other personalized schemes such as Ditto, perFedAvg, and local adaptation with
Resnet18, we searched learning rate over the set
$\\{0.1,0.3,0.01,0.03,0.001,0.003\\}$. The reason for having a larger set of
learning rates for these methods is that we found $0.001$ and $0.003$ work
better for these methods. For SPIDER and local adaptation with Supernet, a
learning rate of 0.001 and 0.003 did not seem a better choice in early stop
explorations. For Ditto, we used $\lambda$ from the set $\\{0.01,0.1,1\\}$. We
used 1000 rounds for the reported results except for perFedAvg, for which we
observed convergence for 1400 rounds.

##  Appendix C Remaining Results on CIFAR10

###  C.1 Personalized Architectures

To investigate the architecture heterogeneity, we also visualize the cell
connection at each client (Figure 7). This confirms that the architectures at
clients are diverse. This heterogeneity has the potential to bring us the
benefit of personalization, each client designs its own architecture to
achieve better performance in a statistical non-I.I.D data setting, and model
privacy, in a sense that these heterogeneous architectures are not shared with
the server.

Figure 6: perFedAvg validation accuracy versus number of rounds for CIFAR10
dataset. Figure 7:  Searched Architectures (Normal Cells): Each normal cell
$k$ takes the outputs of previous cells, cell $k-2$ and cell $k-1$, as its
input. Each cell contains seven nodes: two input nodes, one output node, and
four intermediate nodes inside the cell. The output node concatenates all
intermediate nodes’ output depth-wise. It can be observed that the searched
cells are edge-wise and operation-wise heterogeneous from client to client.

###  C.2 perFedAvg results for CIFAR10.

Since perFedAvg took longer to converge, and the results presented in Table 2
are different from the accuracy value shown in Figure 3(b). Therefore we
report its accuracy curve in Figure 6 to show its superior performance over
Ditto and Local adaptation with resnet18.

##  Appendix D Experiments on CIFAR100 Dataset

This section presents the experimental results of the proposed method, SPIDER
in comparison to local adaptation, perFedAvg and Ditto with CIFAR100 dataset,
another dataset explored by researchers for Federated learning [23]. All our
experiments are based on a non-IID data distribution among FL clients. To
generate non-I.I.D data distribution, we have used latent Dirichlet
Distribution (LDA).

###  D.1 Experimental Setup

#### Implementation and Deployment.

We implement SPIDER for distributed computing with nine nodes, each equipped
with a GPU. Similar to CIFAR10 dataset implementation setup, we set up cross-
silo FL setting for CIFAR100 dataset with one node representing the server and
eight nodes representing the clients.

(a) Label distribution per client

(b) Image distribution per client

Figure 8: CIFAR100: LDA distribution

#### Task and Dataset

We perform an image classification task on another dataset, the CIFAR100
dataset, that consists of 60000 32x32 color images in 100 classes, with 600
images per class. We generate non-IID data across 8 clients by exploiting LDA
distribution with parameter $(\alpha=0.2)$ for the training data of CIFAR100.
The actual data distribution across clients has been shown in figure 8. The
right sub-figure represents the label distribution across clients, where a
darker color indicates more images of that class/label. The left sub-figure
represents the total number of data samples present at each client.

Similar to CIFAR10’s experiments setup, for the CIFAR100 dataset, we split the
total training data samples present at each client into training (50%),
validation (30%), and testing sets (20%). For comparison, we provide results
for local adaptation with resnet18, perFedAvg, and Ditto. Since local
adaptation, perFedAvg, and Ditto do not require any validation dataset, we
split the total training data at each client into (80%) and testing sets (20%)
for these methods. For a fair comparison, we fix the non-IID dataset
distribution in all experiments. Next, we provide Hyperparameter search
details for this experiment.

(a) Average Validation Accuracy comparison

(b) Architecture search vs. Architecture train Phase

Figure 9: Comparison of our proposed method, SPIDER, with other state-of-the-
art personalization methods (perFedAvg, Ditto, and local adaptation). The left
figure shows the average validation accuracy comparison between our proposed
method SPIDER and the other state-of-the-art methods; perFedAvg, Ditto, and
local Adaptation. The right figure illustrates the architecture search
(progressive perturbation of the Supernet) and derived child model’s
architecture train phase of the proposed method. Table 2: Average local
validation Accuracy Comparison of SPIDER with other personalization techniques

Method | Average Accuracy | Parameter Size | FLOPs | Estimated Model Size
---|---|---|---|---
SPIDER | 0.67±0.03 | 392K | 64M | 16MB
Local Adaptation - ResNet18 | 0.61±0.03 | 11M | 76M | 44MB
Ditto - ResNet18 | 0.57±0.03 | 11M | 76M | 44MB
perFedAvg - ResNet18 | 0.64±0.03 | 11M | 76M | 44MB

#### Hyper-parameters

For empirical results of CIFAR100, we use a batch size of 32 for all our
experiments. Furthermore, we use a learning rate in the search range of
$\\{0.1,0.3,0.01,0.01,0.001,0.003\\}$ for SPIDER. For SPIDER, we used
$\lambda$ search from the set of $\\{0.01,0.1,1\\}$. For the local adaptation
with Resnet18, perFedAvg and Ditto, we searched learning rate over the set
$\\{0.1,0.3,0.01,0.03,0.001,0.003\\}$. For Ditto, we used $\lambda$ from the
set $\\{0.01,0.1,1\\}$. We used 1000 number of communication rounds for the
reported results.

###  D.2 Results on Average Validation Accuracy

Here, we report the comparison of our proposed method SPIDER with the other
state-of-the-art personalized methods; Ditto, perFedAvg, and local adaptation.
Given these methods work on a pre-defined architecture, we use the Reset18
model because of its comparable model size to personalized architectures.

Average Validation Accuracy and Personalization. In Figure 9, we provide the
average validation accuracy calculated on each client’s local test dataset
using the personalized architectures they search with SPIDER. The right sub-
figure in Fig. 9 demonstrates the comparison of the proposed method with the
state-of-art methods; Ditto, local adaptation, and perFedAvg. We note that our
method outperforms all three methods by yielding higher accuracy around 67%.
Similar to our observation with the CIFAR10 dataset, perFedAvg yields the
second highest accuracy 64%. We also note that contrary to CIFAR10 results,
Ditto provided the lowest performance among the three personalization methods.
From a personalization perspective, we observe that our method achieves the
same standard deviation, 0.032, as perFedAvg. However, we achieve this
standard deviation with a 3.5% higher mean validation accuracy value. The
local adaptation and Ditto also yield same standard deviation, which
translates to same personalization (fairness) across clients. In a nutshell,
experiments with CIFAR10 and CIFAR100 show that SPIDER with architecture
personalization has the potential to provide higher performance in terms of
higher mean validation accuracy and low/comparable standard deviation
(fairness).

Overall, we observed dominance of SPIDER with higher average accuracy over
other baselines with CIFAR100 as we did for CIFAR10. However, improvement gap
is more prominent with CIFAR100 (3.5%) as compared to CIFAR10 (1.4%) with the
second dominant personalization method, perFedAvg. Moreover, we also note that
with CIFAR100 all baselines yield same standard deviation (0.03) as other
personalization baselines, however, in CIFAR10, Ditto had slightly higher
standard deviation.