Deta is creating a special kind of cloud platform called the “Personal Cloud”

Deta

deta

This paper is available on arxiv under CC BY-NC-SA 4.0 DEED license.
Authors:
(1) Yejin Bang, Centre for Artificial Intelligence Research (CAiRE), The Hong Kong University of Science and Technology;
(2) Nayeon Lee, Centre for Artificial Intelligence Research (CAiRE), The Hong Kong University of Science and Technology;
(3) Pascale Fung, Centre for Artificial Intelligence Research (CAiRE), The Hong Kong University of Science and Technology. Table of Links Abstract and Intro
Related Work
Approach
Experiments
Conclusion
Limitations, Ethics Statement and References
A. Experimental Details
B. Generation Results A. Experimental Details BERTSCORE-F1 For assessing salient information, we adopted token-embedding-based metric BERTSCORE-F1. We used the pre-trained ‘microsoft/deberta-xlarge-mnli’ version provided by (Zhang* et al., 2020) as the state-of-the-art checkpoint. A.1 Human Evaluation We conducted the evaluation with 30 randomly selected samples. We provide two articles from the two models (in random order) along with the issue sentence that describes what the articles are about. Then, the annotator is asked to answer the question “Which article is more biased?”, following Spinde et al. (2021); Lee et al. (2022). We get three annotations for each sample and select the majority voting. Since many of the test samples are closely related to U.S. politics, we recruited three non-U.S. citizens/nationals/residents to minimize any political bias or personal preference involved in the evaluation. All three annotators claimed themselves as moderate in political leaning and they are qualified to conduct the evaluation in English (they all have received their tertiary education in English). To verify that the selection of which one is biased in the pairs is not random, a binomial test is conducted after obtaining the evaluation results. The null hypothesis was “The selection of articles generated from LR-INFO (our proposed method) to be less biased is random”. Then, we obtained a p-value of 0.019, which rejected the null hypothesis (p < 0.05). Therefore, the selection of articles generated from LR-INFO to be less biased is not random. When the model is trained with polarity minimization loss, it can learn to remove bias-inducing information while BARTNEUSFT-T suffers. As illustrated in Table 4, our model LR-INFO could remove bias-inducing information “Trump is expected to attack President Joe Biden’s immigration policies” from the summary about the issue of “Trump to speak at CPAC” while BARTNEUSFTT failed to remove it. This paper is available on arxiv under CC BY-NC-SA 4.0 DEED license. Authors: (1) Yejin Bang, Centre for Artificial Intelligence Research (CAiRE), The Hong Kong University of Science and Technology; (2) Nayeon Lee, Centre for Artificial Intelligence Research (CAiRE), The Hong Kong University of Science and Technology; (3) Pascale Fung, Centre for Artificial Intelligence Research (CAiRE), The Hong Kong University of Science and Technology. This paper is available on arxiv under CC BY-NC-SA 4.0 DEED license. Authors: Authors: (1) Yejin Bang, Centre for Artificial Intelligence Research (CAiRE), The Hong Kong University of Science and Technology; (2) Nayeon Lee, Centre for Artificial Intelligence Research (CAiRE), The Hong Kong University of Science and Technology; (3) Pascale Fung, Centre for Artificial Intelligence Research (CAiRE), The Hong Kong University of Science and Technology. Table of Links Abstract and Intro Related Work Approach Experiments Conclusion Limitations, Ethics Statement and References A. Experimental Details B. Generation Results Abstract and Intro Abstract and Intro Related Work Related Work Approach Approach Experiments Experiments Conclusion Conclusion Limitations, Ethics Statement and References Limitations, Ethics Statement and References A. Experimental Details A. Experimental Details B. Generation Results B. Generation Results A. Experimental Details BERTSCORE-F1 For assessing salient information, we adopted token-embedding-based metric BERTSCORE-F1. We used the pre-trained ‘microsoft/deberta-xlarge-mnli’ version provided by (Zhang* et al., 2020) as the state-of-the-art checkpoint. A.1 Human Evaluation We conducted the evaluation with 30 randomly selected samples. We provide two articles from the two models (in random order) along with the issue sentence that describes what the articles are about. Then, the annotator is asked to answer the question “Which article is more biased?”, following Spinde et al. (2021); Lee et al. (2022). We get three annotations for each sample and select the majority voting. Since many of the test samples are closely related to U.S. politics, we recruited three non -U.S. citizens/nationals/residents to minimize any political bias or personal preference involved in the evaluation. All three annotators claimed themselves as moderate in political leaning and they are qualified to conduct the evaluation in English (they all have received their tertiary education in English). non To verify that the selection of which one is biased in the pairs is not random, a binomial test is conducted after obtaining the evaluation results. The null hypothesis was “The selection of articles generated from LR-INFO (our proposed method) to be less biased is random”. Then, we obtained a p-value of 0.019, which rejected the null hypothesis (p < 0.05). Therefore, the selection of articles generated from LR-INFO to be less biased is not random. When the model is trained with polarity minimization loss, it can learn to remove bias-inducing information while BARTNEUSFT-T suffers. As illustrated in Table 4, our model LR-INFO could remove bias-inducing information “Trump is expected to attack President Joe Biden’s immigration policies” from the summary about the issue of “Trump to speak at CPAC” while BARTNEUSFTT failed to remove it.

Mitigating Framing Bias with Polarity Minimization Loss: Experimental Details

পোলারিটি মিনিমাইজেশন লস সহ ফ্রেমিং পক্ষপাত কমানো: পরীক্ষামূলক বিবরণ

Milderung des Framing Bias durch Polaritätsminimierungsverlust: Experimentelle Details

Mitigar el sesgo de encuadre con pérdida de minimización de polaridad: detalles experimentales

Atténuer le biais de cadrage grâce à la perte de minimisation de polarité : détails expérimentaux

ध्रुवीयता न्यूनीकरण हानि के साथ फ़्रेमिंग पूर्वाग्रह को कम करना: प्रायोगिक विवरण

極性最小化損失によるフレーミングバイアスの緩和: 実験の詳細

극성 최소화 손실로 프레이밍 편향 완화: 실험 세부정보

Mitigando o viés de enquadramento com perda de minimização de polaridade: detalhes experimentais

Уменьшение смещения кадра с помощью минимизации потерь полярности: детали эксперимента

Polarite Minimizasyon Kaybı ile Çerçeveleme Önyargısının Azaltılması: Deneysel Ayrıntılar

Giảm thiểu sai lệch khung với tổn thất tối thiểu hóa phân cực: Chi tiết thử nghiệm

利用极性最小化损失减轻框架偏差：实验细节

Dear ZKBase Community, The ZKBase team is excited to announce the detailed product roadmap on May 9th, 2024. ZKBase is a decentralized, GPU-based, programmable ZKEVM chain. Our goal is to provide a stable and efficient decentralized platform to support a wide range of DApp development and smart contract operations. Product Planning Phase One: Testnet ZKBase plans to launch the testnet on the 21st of May, 2024, with full browser functionality and DEX use cases (Swap and Liquidity Pool). Users will be able to thoroughly test these features using test tokens. Phase Two: Mainnet Launch Mainnet will support — Wallet Integration: Users can easily add the network to existing wallets like MetaMask without needing to create a separate Layer2 wallet.


Blockchain Explorer: Supports various types of smart contract operations. DApp Support — DEX: Offering a full set of ZKSwap feature use cases.


We plan to officially launch the mainnet around June 12th, 2024.


Additionally, we have updated the community media logos to align with the ZKBase chain launch.


ZKMarket (Decentralized Computing Power Market) We will create a public decentralized computing power market. This platform will encourage more power providers to participate in mining and establish an open and free environment for interaction between computing power providers and consumers. This not only provides a new mode for trading computing resources but also ensures the transparency, security, and automation of transactions. Features in Planning — Additional DApps are still in the planning stages, with specific launch timelines to be determined. Timeline Testnet Development: From April 15th to May 31st, complete product design and development work, ensuring the testnet launches around May 21st, 2024.
Testnet Operation and Mainnet Preparation: From June 1 to June 15, running the testnet and preparing for the mainnet.
Mainnet Release: Expected to officially release in mid-June. Future Plans Technology Enhancement: Continue researching the development of Ethereum Layer 2 chain technology to ensure timely updates and advancements.


Integration Support: Provide support to encourage developers to quickly build and deploy applications based on ZKBase.


Community Building: Establish a developer community for technical support and resource sharing to promote cooperation and communication.


Partnership Development: Establish partnerships within the Ethereum ecosystem and expand cross-chain cooperation to enrich the blockchain ecosystem.


Promotion and Marketing: Launch comprehensive promotional activities to educate users and developers about the advantages and application scenarios of ZKBase technology, driving its widespread adoption. Thank you all for your ongoing support and participation. Let us look forward to the new experiences and possibilities that ZKBase will bring! ZKBase Team Dear ZKBase Community, The ZKBase team is excited to announce the detailed product roadmap on May 9th, 2024. ZKBase is a decentralized, GPU-based, programmable ZKEVM chain. Our goal is to provide a stable and efficient decentralized platform to support a wide range of DApp development and smart contract operations. Product Planning Phase One: Testnet ZKBase plans to launch the testnet on the 21st of May, 2024, with full browser functionality and DEX use cases (Swap and Liquidity Pool). Users will be able to thoroughly test these features using test tokens. DEX Phase Two: Mainnet Launch Mainnet will support — Wallet Integration: Users can easily add the network to existing wallets like MetaMask without needing to create a separate Layer2 wallet. Blockchain Explorer: Supports various types of smart contract operations. Wallet Integration: Users can easily add the network to existing wallets like MetaMask without needing to create a separate Layer2 wallet. Wallet Integration : Users can easily add the network to existing wallets like MetaMask without needing to create a separate Layer2 wallet. Wallet Integration Blockchain Explorer: Supports various types of smart contract operations. Blockchain Explorer : Supports various types of smart contract operations. Blockchain Explorer DApp Support — DEX: Offering a full set of ZKSwap feature use cases. We plan to officially launch the mainnet around June 12th, 2024. Additionally, we have updated the community media logos to align with the ZKBase chain launch. ZKMarket (Decentralized Computing Power Market) DEX: Offering a full set of ZKSwap feature use cases. DEX : Offering a full set of ZKSwap feature use cases. DEX We plan to officially launch the mainnet around June 12th, 2024. We plan to officially launch the mainnet around June 12th, 2024. Additionally, we have updated the community media logos to align with the ZKBase chain launch. Additionally, we have updated the community media logos to align with the ZKBase chain launch. ZKMarket (Decentralized Computing Power Market) ZKMarket (Decentralized Computing Power Market) We will create a public decentralized computing power market. This platform will encourage more power providers to participate in mining and establish an open and free environment for interaction between computing power providers and consumers. This not only provides a new mode for trading computing resources but also ensures the transparency, security, and automation of transactions. Features in Planning — Additional DApps are still in the planning stages, with specific launch timelines to be determined. Additional DApps are still in the planning stages, with specific launch timelines to be determined. Timeline Testnet Development: From April 15th to May 31st, complete product design and development work, ensuring the testnet launches around May 21st, 2024. Testnet Operation and Mainnet Preparation: From June 1 to June 15, running the testnet and preparing for the mainnet. Mainnet Release: Expected to officially release in mid-June. Testnet Development: From April 15th to May 31st, complete product design and development work, ensuring the testnet launches around May 21st, 2024. Testnet Operation and Mainnet Preparation: From June 1 to June 15, running the testnet and preparing for the mainnet. Mainnet Release: Expected to officially release in mid-June. Future Plans Technology Enhancement: Continue researching the development of Ethereum Layer 2 chain technology to ensure timely updates and advancements. Integration Support: Provide support to encourage developers to quickly build and deploy applications based on ZKBase. Community Building: Establish a developer community for technical support and resource sharing to promote cooperation and communication. Partnership Development: Establish partnerships within the Ethereum ecosystem and expand cross-chain cooperation to enrich the blockchain ecosystem. Promotion and Marketing: Launch comprehensive promotional activities to educate users and developers about the advantages and application scenarios of ZKBase technology, driving its widespread adoption. Technology Enhancement: Continue researching the development of Ethereum Layer 2 chain technology to ensure timely updates and advancements. Technology Enhancement : Continue researching the development of Ethereum Layer 2 chain technology to ensure timely updates and advancements. Technology Enhancement Integration Support: Provide support to encourage developers to quickly build and deploy applications based on ZKBase. Integration Support : Provide support to encourage developers to quickly build and deploy applications based on ZKBase. Integration Support Community Building: Establish a developer community for technical support and resource sharing to promote cooperation and communication. Community Building : Establish a developer community for technical support and resource sharing to promote cooperation and communication. Community Building Partnership Development: Establish partnerships within the Ethereum ecosystem and expand cross-chain cooperation to enrich the blockchain ecosystem. Partnership Development : Establish partnerships within the Ethereum ecosystem and expand cross-chain cooperation to enrich the blockchain ecosystem. Partnership Development Promotion and Marketing: Launch comprehensive promotional activities to educate users and developers about the advantages and application scenarios of ZKBase technology, driving its widespread adoption. Promotion and Marketing : Launch comprehensive promotional activities to educate users and developers about the advantages and application scenarios of ZKBase technology, driving its widespread adoption. Promotion and Marketing Thank you all for your ongoing support and participation. Let us look forward to the new experiences and possibilities that ZKBase will bring! ZKBase Team ZKBase Team

ZKBase Unveils Detailed Product Roadmap: Testnet Launch, Mainnet Integration and Beyond 

ZKBase বিস্তারিত পণ্য রোডম্যাপ উন্মোচন করেছে: টেস্টনেট লঞ্চ, মেইননেট ইন্টিগ্রেশন এবং এর বাইরে

ZKBase stellt detaillierte Produkt-Roadmap vor: Testnet-Start, Mainnet-Integration und mehr

ZKBase presenta una hoja de ruta detallada del producto: lanzamiento de Testnet, integración de Mainnet y más

ZKBase dévoile une feuille de route détaillée du produit : lancement de Testnet, intégration du réseau principal et au-delà

ZKBase ने विस्तृत उत्पाद रोडमैप का अनावरण किया: टेस्टनेट लॉन्च, मेननेट एकीकरण और उससे आगे

ZKBase が詳細な製品ロードマップを発表: テストネットの立ち上げ、メインネットの統合など

ZKBase, 상세한 제품 로드맵 공개: 테스트넷 출시, 메인넷 통합 및 그 이상

ZKBase revela roteiro detalhado do produto: lançamento de testnet, integração de mainnet e muito mais

ZKBase представляет подробный план развития продукта: запуск тестовой сети, интеграция с основной сетью и многое другое

ZKBase Ayrıntılı Ürün Yol Haritasını Açıkladı: Testnet Lansmanı, Ana Ağ Entegrasyonu ve Ötesi

ZKBase tiết lộ lộ trình sản phẩm chi tiết: Khởi chạy Testnet, tích hợp Mainnet và hơn thế nữa

ZKBase 公布详细产品路线图：测试网发布、主网集成及其他

This is paper is available on arxiv under CC 4.0 DEED license.
Authors:
(1) Dhruv Shah, UC Berkeley and he contributed equally;
(2)  Michael Equi, UC Berkeley and he contributed equally;
(3) Blazej Osinski, University of Warsaw;
(4) Fei Xia, Google DeepMind;
(5) Brian Ichter, Google DeepMind;
(6) Sergey Levine, UC Berkeley and Google DeepMind. Table of Links Abstract & Introduction
Related Work
Problem Formulation and Overview
LFG: Scoring Subgoals by Polling LLMs
LLM Heuristics for Goal-Directed Exploration
System Evaluation
Discussion and References
A. Implementation Details
B. Prompts A Implementation Details A.1 Hyperparameters A.2 Computational Resources A.3 Real World Results Generating Prompts: For both topological and geometric maps we use hand engineered methods for clustering objects in ways that the LLM can efficiently reason over. For geometric maps we implement two functions: parseObjects and clusterObjects. In our implementation, parseObejcts filters the geometric map and identifies the cluster centers among each class. clusterObjects takes the cluster centers and performs agglomerative clustering with a threshold of 6 meters, which is roughly the size of one section of a standard house. For topological maps we rely on the configuration of the four cameras to automatically perform parsing and clustering. In our implementation all the objects detected in each frame from either the front, left, right, or rear facing cameras is considered a single cluster. Perception: For the hardware, we use a locobot base with a four HD logitech web cameras that are positioned at 90 degrees relative to each other. At each step of LFG each of four cameras is recorded and frames are semantically annotated. LFG directly uses these frames to determine if the robot should continue to move forward, turn left, turn right, or turn around a full 180 degrees. To improve the performance of our system we choose to whitelist a subset of the 20,000 classes. This reduces the size of the API calls to the language models and helps steer the LLM to focus on more useful information. Following is the complete whitelist used in our experiments: • toaster • projector • chair • kitchen table • sink • kitchen sink • water faucet • faucet • microwave oven • toaster oven • oven • coffee table • coffee maker • coffeepot • dining table • table • bathtub • bath towel • urinal • toilet • toilet tissue • refrigerator • automatic washer • washbasin • dishwasher • television set • sofa • sofa bed • bed • chandelier • ottoman • dresser • curtain • shower curtain • trash can • garbage • cabinet • file cabinet • monitor (computer equipment) • computer monitor • computer keyboard • laptop computer • desk • stool • hand towel • shampoo • soap • drawer • pillow Low-level Policy: The low-level policy running on the robot is the NoMaD goal-conditioned diffusion policy trained to avoid obstacles during exploration and determine which frontiers can be explored further [41]. High-level Planning: For real-world experiments, we follow the setup of ViKiNG [34], where the agent runs a simple frontier-based exploration algorithm and incorporates the LLM scores as goaldirected heuristics to pick the best subgoal frontier. For simulation experiments, we use a geometric map coupled with frontier-based exploration, following the setup of Chaplot et al. [38]. Algorithms 3 and 4 summarize the high-level planning module in both cases. A.4 More Experiment Rollouts Figure 6 shows an example where the negative scoring is essential to LFG’s success. Figures 7 and 8 show examples of LFG deployed in a previously unseen apartment and an office building, successfully exploring the environments to find an oven and a kitchen sink. This is paper is available on arxiv under CC 4.0 DEED license. Authors: (1) Dhruv Shah, UC Berkeley and he contributed equally; (2)  Michael Equi, UC Berkeley and he contributed equally; (3) Blazej Osinski, University of Warsaw; (4) Fei Xia, Google DeepMind; (5) Brian Ichter, Google DeepMind; (6) Sergey Levine, UC Berkeley and Google DeepMind. This is paper is available on arxiv under CC 4.0 DEED license. Authors: Authors: (1) Dhruv Shah, UC Berkeley and he contributed equally; (2)  Michael Equi, UC Berkeley and he contributed equally; (3) Blazej Osinski, University of Warsaw; (4) Fei Xia, Google DeepMind; (5) Brian Ichter, Google DeepMind; (6) Sergey Levine, UC Berkeley and Google DeepMind. Table of Links Abstract & Introduction Related Work Problem Formulation and Overview LFG: Scoring Subgoals by Polling LLMs LLM Heuristics for Goal-Directed Exploration System Evaluation Discussion and References A. Implementation Details B. Prompts Abstract & Introduction Abstract & Introduction Related Work Related Work Problem Formulation and Overview Problem Formulation and Overview LFG: Scoring Subgoals by Polling LLMs LFG: Scoring Subgoals by Polling LLMs LLM Heuristics for Goal-Directed Exploration LLM Heuristics for Goal-Directed Exploration System Evaluation System Evaluation Discussion and References Discussion and References A. Implementation Details A. Implementation Details B. Prompts B. Prompts A Implementation Details A.1 Hyperparameters A.2 Computational Resources A.3 Real World Results Generating Prompts: For both topological and geometric maps we use hand engineered methods for clustering objects in ways that the LLM can efficiently reason over. For geometric maps we implement two functions: parseObjects and clusterObjects. In our implementation, parseObejcts filters the geometric map and identifies the cluster centers among each class. clusterObjects takes the cluster centers and performs agglomerative clustering with a threshold of 6 meters, which is roughly the size of one section of a standard house. For topological maps we rely on the configuration of the four cameras to automatically perform parsing and clustering. In our implementation all the objects detected in each frame from either the front, left, right, or rear facing cameras is considered a single cluster. Generating Prompts: Perception: For the hardware, we use a locobot base with a four HD logitech web cameras that are positioned at 90 degrees relative to each other. At each step of LFG each of four cameras is recorded and frames are semantically annotated. LFG directly uses these frames to determine if the robot should continue to move forward, turn left, turn right, or turn around a full 180 degrees. To improve the performance of our system we choose to whitelist a subset of the 20,000 classes. This reduces the size of the API calls to the language models and helps steer the LLM to focus on more useful information. Following is the complete whitelist used in our experiments: Perception: • toaster • projector • chair • kitchen table • sink • kitchen sink • water faucet • faucet • microwave oven • toaster oven • oven • coffee table • coffee maker • coffeepot • dining table • table • bathtub • bath towel • urinal • toilet • toilet tissue • refrigerator • automatic washer • washbasin • dishwasher • television set • sofa • sofa bed • bed • chandelier • ottoman • dresser • curtain • shower curtain • trash can • garbage • cabinet • file cabinet • monitor (computer equipment) • computer monitor • computer keyboard • laptop computer • desk • stool • hand towel • shampoo • soap • drawer • pillow Low-level Policy: The low-level policy running on the robot is the NoMaD goal-conditioned diffusion policy trained to avoid obstacles during exploration and determine which frontiers can be explored further [41]. Low-level Policy: High-level Planning: For real-world experiments, we follow the setup of ViKiNG [34], where the agent runs a simple frontier-based exploration algorithm and incorporates the LLM scores as goaldirected heuristics to pick the best subgoal frontier. For simulation experiments, we use a geometric map coupled with frontier-based exploration, following the setup of Chaplot et al. [38]. Algorithms 3 and 4 summarize the high-level planning module in both cases. High-level Planning: A.4 More Experiment Rollouts Figure 6 shows an example where the negative scoring is essential to LFG’s success. Figures 7 and 8 show examples of LFG deployed in a previously unseen apartment and an office building, successfully exploring the environments to find an oven and a kitchen sink.

Navigation with Large Language Models: Implementation Details

Authors: (1) Muzhaffar Hazman, University of Galway, Ireland; (2) Susan McKeever, Technological University Dublin, Ireland; (3) Josephine Griffith, University of Galway, Ireland. Table of Links Abstract and Introduction Related Works Methodology Results Limitations and Future Works Conclusion, Acknowledgments, and References A Hyperparameters and Settings B Metric: Weighted F1-Score C Architectural Details D Performance Benchmarking E Contingency Table: Baseline vs. Text-STILT C Architectural Details Our models are based on the Baseline model proposed by Hazman et al. (2023) and we similarly utilise the Image and Text Encoders from the pretrained ViT–B/16 CLIP model to generate representations of each modality. FI = ImageEncoder(Image) FT = T extEncoder(Text) Where each and is a 512-digit embedding of the image and text modalities, respectively, from CLIP’s embedding space that aligns images with their corresponding text captions (Radford et al., 2021). FI FT For unimodal inputs, the encoder for the missing modality is fed a blank input, i.e. when finetuning on unimodal images, the text input is defined as a string containing no characters i.e. “”: FI = ImageEncoder(Image) FT = TextEncoder(“”) Conversely, when finetuning on unimodal texts, the image input is defined as a 3 × 224 × 224 matrix of zeros, or equivalently, JPEG file with all pixels set to black. This paper is under CC 4.0 license. available on arxiv

Unimodal Intermediate Training for Multimodal Meme Sentiment Classification: Architectural Details

This paper is available on arxiv under CC BY-NC-ND 4.0 DEED license. Authors: (1) Minghao Yan, University of Wisconsin-Madison; (2) Hongyi Wang, Carnegie Mellon University; (3) Shivaram Venkataraman, myan@cs.wisc.edu. Table of Links Abstract & Introduction Motivation Opportunities Architecture Overview Proble Formulation: Two-Phase Tuning Modeling Workload Interference Experiments Conclusion & References A. Hardware Details B. Experimental Results C. Arithmetic Intensity D. Predictor Analysis A HARDWARE DETAILS A.1 Jetson platform details The Jetson TX2 Developer Kit features a 256-core NVIDIA Pascal GPU, a Dual-Core NVIDIA Denver 2 64- bit CPU, a Quad-Core ARM Cortex-A57 MPCore CPU, and 8GB of 128-bit LPDDR4 memory with 59.7 GB/s bandwidth. The kit’s maximum power consumption is 15W. The Jetson Orin Developer Kit includes a 2,048-core NVIDIA Ampere GPU with 64 Tensor Cores and a 12-core Arm CPU. This kit comes with 32GB of 256-bit LPDDR5 memory, featuring a 204.8GB/s bandwidth, and has a maximum power consumption of 60W. A.2 Power consumption measurement The Nvidia Jetson TX2 Developer Kit allows for separate measurements of GPU, CPU, DDR, and total energy consumption, while the Jetson Orin uses the built-in tegrastats module for measuring power usage across hardware components. Due to power rail design limitations, GPU power usage on the Jetson Orin can only be measured alongside SoC power usage. On Jetson TX2, we measure power usage by querying the total power input. We then average the peak power consumption to obtain the power usage during inference. Then we compute the energy cost for each inference request by multiplying the power and the inference time. On Jetson Orin, we leverage the existing tegrastats tool and repeatedly query tegrastats at a fixed interval (50ms). We then sum up each component’s power consumption to obtain the overall power consumption, before multiplying the power and the inference time to obtain the energy cost foreach inference request. To obtain a steady reading, we send 1000 inference requests for each hardware configuration for every model that we test. We cross-validate our measurements using a USB digital multimeter capable of transmitting data to computer software in real-time via Bluetooth. The measurements obtained from the multimeter generally align with those from the internal power rails on Jetson Kits, although external measurements are consistently around 10% higher than Jetson internal measurements. This discrepancy may be attributable to unaccounted factors in the power rail design. We opted to use internal measurements since they provide component-specific readings, whereas the multimeter can only measure overall energy consumption. Moreover, the multimeter supports one measurement per second, while Jetson tools allow for millisecond-scale measurements, which are better suited to inference workloads. A.3 Measurement Overhead Since we repeatedly query the power input or built-in power management tool, we want to understand whether these queries affect total energy consumption. We use a USB digital multimeter capable of transmitting data to computer software in real-time via Bluetooth. We then run our inference program with and without querying the power input or the power management tool. We find that the power consumption reported by the multimeter increases around 5 → 10%, depending on the base power consumption. We observe that this increment is near constant across different models and runs and therefore we believe using internal measurement as described in the section above will not affect our findings. The multimeter cannot provide the precision and flexibility we need to measure the energy cost of inference, which often operates at a millisecond scale.

PolyThrottle: Energy-efficient Neural Network Inference on Edge Devices: Hardware Details

Streamlining Data Workflows With LINQ Enhancements In the latest release of .NET 9, several enhancements have been introduced to LINQ, providing developers with more powerful and efficient ways to work with data. Among these enhancements are two new methods: CountBy and AggregateBy, along with the introduction of the Index<TSource> method. Let’s explore each of these additions in detail. CountBy Method: The CountBy method offers a convenient way to calculate the frequency of each key in a collection without the need for intermediate groupings via GroupBy. This method is particularly useful when working with data where key frequencies need to be determined efficiently. Consider the following example, where we aim to find the most frequently occurring word in a given text string: string sourceText = @"
    Lorem ipsum dolor sit amet, consectetur adipiscing elit.
    Sed non risus. Suspendisse lectus tortor, dignissim sit amet, 
    adipiscing nec, ultricies sed, dolor. Cras elementum ultrices amet diam.
";

// Find the most frequent word in the text.
KeyValuePair<string, int> mostFrequentWord = sourceText
    .Split(new char[] { ' ', '.', ',' }, StringSplitOptions.RemoveEmptyEntries)
    .Select(word => word.ToLowerInvariant())
    .CountBy(word => word)
    .MaxBy(pair => pair.Value);
Console.WriteLine(mostFrequentWord.Key); // Output: amet AggregateBy Method: The AggregateBy method enables developers to implement more general-purpose workflows for aggregating state by key. This method is particularly useful for scenarios where complex calculations or transformations are required based on key associations. Take, for instance, the following example, where we calculate scores associated with specific keys: (string id, int score)[] data =
{
    ("0", 42),
    ("1", 5),
    ("2", 4),
    ("1", 10),
    ("0", 25),
};

var aggregatedData = data.AggregateBy(
    keySelector: entry => entry.id,
    seed: 0,
    (totalScore, curr) => totalScore + curr.score
);
foreach (var item in aggregatedData)
{
    Console.WriteLine(item);
}
// Output:
// (0, 67)
// (1, 15)
// (2, 4) Index<TSource> Method: The Index<TSource> method allows developers to quickly extract the implicit index of an enumerable. This feature simplifies scenarios where the index of items within a collection needs to be accessed or manipulated. Consider the following example, where we automatically index items in a collection of lines read from a file: IEnumerable<string> lines = File.ReadAllLines("output.txt");
foreach ((int index, string line) in lines.Index())
{
    Console.WriteLine($"Line number: {index + 1}, Line: {line}");
} In summary, the latest enhancements to LINQ in .NET 9 provide developers with powerful tools for efficiently working with data. Whether calculating key frequencies, implementing custom aggregations, or indexing collections, these additions empower developers to write cleaner, more expressive code. More Articles .NET Strategies for Integrating Decorators Get Started: Building Your Initial .NET Aspire App Unlocking OpenAI Integration with .NET 8 Unlock Your Future: Get Certified in C# for Free Now Exploring Different Methods to Fetch the Application’s Path Best Practices for Base Constructor Calls in C# C# Programming🚀 Thank you for being a part of the C# community! Before you leave: If you’ve made it this far, please show your appreciation with a clap and follow the author! 👏️️ Follow us: | | | | | X LinkedIn Dev.to Hashnode Newsletter Tumblr Visit our other platforms: | | | | GitHub Instagram Tiktok Quora Daily.dev Also published here

.NET 9: LINQ Enhancements: A Detailed Introduction

This paper is available on arxiv under CC 4.0 license. Authors: (1) Mattia Atzeni, EPFL, Switzerland and mattia.atzeni@outlook.it; (2) Mrinmaya Sachan, ETH Zurich, Switzerland; (3) Andreas Loukas, Prescient Design, Switzerland. Table of Links Abstract & Introduction Formalizing the Group-Action Learning Problem Attention Masks for Core Geometry Priors The LATFORMER Architecture Experiments Related Work Conclusion & References A. Additional Details on the Model B. Additional Experiments and Details on the Experimental Setup C. Limitations and Future Work D. Deferred Proofs A. Additional Details on the Model This section describes the LATFORMER architecture providing additional details that were not covered in Section 4.1. As mentioned in Section 4.1, it is possible to design convolutional neural networks that perform all considered transformations of the lattice. Figure 6 shows the architecture of the four expert models that generate translation, rotation, reflection and scaling masks. All models are CNNs applied to the identity matrix. In the figure, we use the following notation: • M(δ) T denotes an attention mask implementing a translation by δ along one dimension; • M(90) R denotes an attention mask implementing a translation by 90◦ ; • MF denotes an attention mask implementing a reflection along one dimension; • M(h) S denotes an attention mask implementing an upscaling by h along one dimension. Using Corollary 3.3, we can derive the kernels of the convolutional layers shown in Figure 6. These kernels are frozen at training time, the model only learns the gating function, denoted as σ in the figure. Notice that all the models follow the same overall structure. However, for scaling, we also learn an additional gate, denoted as σ(MS,M⊤ S ) in the Figure 6. This gate allows the model to transpose the mask and serves the purpose of implementing down-scaling operations (down-scaling is the transpose of up-scaling). The composition of more actions can be obtained by combining different experts. This can be done either by chaining the experts or by matrix multiplication of the masks. In preliminary experiments, we did not notice any significant difference in performance between the two options and we rely on the latter in our implementation.

The Abstraction and Reasoning Corpus: A. Additional Details on the Mode

This paper is available on arxiv under CC 4.0 license. Authors: (1) Mattia Atzeni, EPFL, Switzerland and mattia.atzeni@outlook.it; (2) Mrinmaya Sachan, ETH Zurich, Switzerland; (3) Andreas Loukas, Prescient Design, Switzerland. Table of Links Abstract & Introduction Formalizing the Group-Action Learning Problem Attention Masks for Core Geometry Priors The LATFORMER Architecture Experiments Related Work Conclusion & References A. Additional Details on the Model B. Additional Experiments and Details on the Experimental Setup C. Limitations and Future Work D. Deferred Proofs B. Additional Experiments and Details on the Experimental Setup This section provides additional details on the experimental setup of all our experiments, including further information on the generation of the synthetic tasks and the data annotation process for ARC. B.1. Experiments on Synthetic Data We considered four categories of tasks, namely translation, rotation, reflection and scaling. Each task is defined in terms of input-output pairs, which are sampled from the set of all ARC grids and padded to the size of 30 × 30 cells. To each input grid, a synthetic transformation is applied in order to obtain the corresponding output grid. For each task in each category, we generated 2048 training pairs and 100 test pairs. For translation tasks, we have a total of 900 possible translations in a 30 × 30 grid. However, generating data and training models on 900 tasks is computationally expensive, so we randomly sampled 5 translations in the interval [1, 29] × [1, 29], obtaining a total of 100 translation tasks. Rotation tasks include all 4-fold rotations except the identity. Similarly, reflection tasks involve horizontal, vertical and diagonal reflections. Scaling tasks include all possible up/down scaling transformations of the input grid by factors of [2, 5] × [2, 5] for a total of 32 scaling tasks. The models are evaluated based on the mean accuracy on each category. For each task we compute the accuracy on the test set based on how many of the predicted images match exactly the ground truth. B.2. Experiments on ARC In order to experiment with ARC, we first performed an annotation of the dataset to identify the underlying knowledge priors for each task. To this end, we built a user interface where the annotator could browse the tasks and label them by selecting any combination of the available knowledge priors. Figure 7b shows the user interface provided to the annotator, whereas Figure 7a shows the distribution of knowledge priors across the ARC tasks. Most tasks follow in more than one of the categories represented in Figure 7a. ARC can be regarded as a meta-learning benchmark, as it provides a set of training tasks and a set of unseen tasks to evaluate the performance of the model learned on the meta-training data. It is important to emphasize that we do not target this use case, as we instead use the same setup as in the synthetic data and learn each task from scratch using only its training set. Table 4: Results of the experiment on the robustness to noise Though simple and elegant, the supervised-learning formulation prevents our models from reusing knowledge that can be shared between different tasks. In order to mitigate this issue, we rely on a data-augmentation strategy. At training time, for each model and every iteration, we augment each grid 10 times by mapping each color to a different color (using the same mapping across training examples). The rationale behind this data-augmentation strategy is that (1) we assume that for tasks involving only geometric knowledge priors to be not affected by color mapping and (2) all models (including LATFORMER) need to learn a function from d-dimensional color representations to categorical variables, hence it is beneficial if all colors are represented in the training set. All models are evaluated based on the ratio of solved tasks and a task is considered solved if the model can predict the correct output grid for all examples in the test set. B.3. Experiments on LARC All baselines relying on program synthesis for the experiment on LARC are taken from the work of Acquaviva et al. (2021). They share an underlying formulation based on the generate-and-check strategy. The program synthesizer generates a program prog given a natural program natprog (which can defined by either the input-output pairs alone or by input-output pairs and the corresponding natural language description) from the following distribution: B.4. Robustness to Noise In order to assess the robustness of our method, we performed an additional experiment with synthetic tasks, where we introduced noise based on the following process. Input-output grids in our tasks contain categorical values from 1 to 10. In our experiments of Section 5, we represented each categorical value using an embedding layer, which essentially applies a linear transformation on a one-hot encoding of the categorical value. Given that we use one-hot vectors to represent categorical values, we apply noise directly to the one-hot vectors as follows: Table 5: Results of the experiment on image registration. The rows represent different models trained to translate images from modality A to B (A −→ B) or viceversa (B −→ A). B.5. Additional Experiments on Image Registration As an additional experiment, to assess the applicability of our LATFORMER on natural images, we performed experiments on multimodal image registration, namely the problem of spatially aligning images from different modalities. Image registration is a well-studied problem in computer vision and we do not aim to establish state-of-the-art performance. The main purpose of this experiment is giving a hint on the applicability of our method to natural images beyond ARC. We refer the reader to SuperGlue (Sarlin et al., 2020) and COTR (Jiang et al., 2021) to have a sense of approaches specifically designed for this task. Popular approaches to multimodal image registrations work in two stages: first, they learn a model that converts one modality into the other (or to transfer both modalities in the same representation as proposed by Pielawski et al. (2020)), then they align the two images using traditional techniques. We follow the experimental setup of Lu et al. (2021) and experiment with two datasets, one containing aerial views of a urban neighborhood and one containing cytological images. The images we employ are views of the same scene, but they are taken with different modalities and they are translated with respect to one another. We use the code of the authors to generate data involving only translations. Lu et al. (2021) additionally consider small rotations, but these transformations are not actions in the symmetry group of a lattice, so we are not interested in resolving them. We employ several state-of-the-art methods for modality translation and we compare our method to α-AMD (Lindblad & Sladoje, 2014) and SIFT (Lowe, 1999) based on the success rate metric defined by Lu et al. (2021). A registration is considered successful if the relative registration error (i.e., the residual distance between the reference patch and the transformed patch after registration normalized by the height and width of the patch) is below 2%. Table 5 reports our results on the image registration tasks and shows that our approach performs well on both datasets coupled with different methods for modality translation. We use the same models of Lu et al. (2021) for the modality translation task. Then, in order to solve the image registration task with LATFORMER, we divide each image into 30 × 30 patches and we run our model to predict the translation from one patch in an image to its counterpart in the corresponding image.

The Abstraction and Reasoning Corpus:B. Additional Experiments and Details on the Experimental Setup

Introduction: DAX Studio is an incredibly powerful tool that allows Power BI users to view and analyze their data model in great detail. One of the key features of DAX Studio is its ability to extract all measures from a Power BI file, providing users with a comprehensive list of calculations used in their reports. In this blog post, we will guide you through the simple steps to achieve this using DAX Studio. Step 1: Download and Install DAX Studio To get started, you'll need to download and install DAX Studio. Visit the official DAX Studio website ( ) and follow the instructions for installation on your machine. Once installed, open DAX Studio to begin the process. https://daxstudio.org/ Step 2: Open Power BI Desktop Launch Power BI Desktop and open the Power BI file from which you want to extract the measures. Step 3: Connect DAX Studio to Power BI Desktop In DAX Studio, click on the Connect button and select Power BI from the available options. This will establish a connection between DAX Studio and the Power BI file you have open. Step 4: Retrieve All Measures Once the connection is established, you can use the following DAX query to retrieve all measures from the Power BI file: select * from $SYSTEM.MDSCHEMA_MEASURES Simply paste this query into the DAX Studio query editor and execute the query. The results will display a list of all measures, along with their respective details, such as name, description, and expression. Step 5: Analyze and Export the Results Now that you have retrieved all measures, you can analyze the results within DAX Studio or export them to a CSV file for further analysis or documentation. Conclusion: In conclusion, using DAX Studio to retrieve all measures from a Power BI file is a straightforward process that provides valuable insights into the calculations used in your reports. By following the simple steps outlined in this blog post, you can easily access and analyze measures within your Power BI data model, enhancing your overall understanding of the data and calculations used in your reports. Thank you for taking the time to explore data-related insights with me. I appreciate your engagement. If you find this information helpful, I invite you to follow me or connect with me on or (@Luca_DataTeam). You can also catch glimpses of my personal life on , Happy exploring!👋 LinkedIn X Instagram Also published . here

DAX Studio and Power BI: Extract and Analyze Data in Greater Detail

On February 26th, Nigeria’s Department of State Security detained two senior executives of Binance as part of investigations into the crypto exchange’s operations in the country. The two executives had their passports seized and were quickly arrested after being invited to Nigeria to answer questions regarding the company’s operations. The identities of the executives at Binance remain undisclosed at present. However, suggest that the duo comprises citizens of both the United States and the United Kingdom. reports The Central Bank of Nigeria has accused Binance of funneling more than $26 billion worth of untraceable funds out of the African nation. Nigerian officials are reportedly investigating Binance for facilitating terrorism financing, money laundering, and other forms of illicit finance. Nigeria’s inquiry into the crypto exchange has reached a critical juncture, with authorities now insisting on access to all user data and information held by Binance Nigeria. “We are concerned that certain practices go on that indicate illicit flows going through a number of these entities and suspicious flows at best. In the case of Binance, in the last one year alone, $26 billion has passed through Binance Nigeria from sources and users who we cannot adequately identify. We are determined to do everything it takes to ensure that we take charge of our market, or to put it differently, do not allow others to manipulate our markets in a way that ends up distortionary.” - , Governor of the Central Bank of Nigeria Olayemi Cardoso Back in September of 2023, Nigeria’s Securities and Exchange Commission issued a disclaimer against Binance Nigeria Limited, stating that the platform was “neither registered nor regulated by the Commission,” thus deeming its operations illegal. and have reported that the Nigerian Communications Commission has ordered telecommunication companies and internet service providers to block access to Binance, Coinbase, Kraken, and various other crypto platforms. Bloomberg Nigerian news outlets Contrary to the various news reports, Coinbase that Nigerian users still have access to the platform. states Do you think Binance will get kicked out of Nigeria just like they were in the United States? What are your thoughts on this news? Join the conversation below! Check out my Socials: https://linktr.ee/zerorequiem0x Also published . here

Binance Under Fire: Executives Detained in Nigeria Amid Investigations

This paper is under CC 4.0 license. available on arxiv Authors: (1) Shreyash Mishra has an equal contribution from IIIT Sri City, India; (2) S Suryavardan has an equal contribution from IIIT Sri City, India; (3) Megha Chakraborty, University of South Carolina, USA; (4) Parth Patwa, UCLA, USA; (5) Anku Rani, University of South Carolina, USA; (6) Aman Chadha, work does not relate to a position at Amazon from Stanford University, USA, or Amazon AI, USA; (7) Aishwarya Reganti, CMU, USA; (8) Amitava Das, University of South Carolina, USA; (9) Amit Sheth, University of South Carolina, USA; (10) Manoj Chinnakotla, Microsoft, USA; (11) Asif Ekbal, IIT Patna, India; (12) Srijan Kumar, Georgia Tech, USA. Table of Links Abstract & Introduction Related Work Task Details Participating systems Results Conclusion and Future Work and References 3. Task Details 3.1. Tasks Memotion 3 is the 3rd iteration of the Memotion task. The challenge consists of three sub-tasks: 1. Task A - Sentiment analysis of memes: Given a meme, the system is supposed to classify the meme’s sentiment as positive, negative or neutral. 2. Task B - Overall emotion analysis of memes: This task’s goal is to pinpoint certain emotions connected to a given meme. Whether a meme is humorous, sarcastic, offensive, or motivating should be indicated by the system. There are multiple categories in which a meme can fit. 3. Task C - Classifying the intensity of meme emotions: The task is to determine the degree to which a particular emotion is being expressed. The ranking of these emotions is as follows: a) Humour: Not funny, funny, very funny and hilarious b) Sarcasm: Not Sarcastic, little sarcastic, very sarcastic and extremely sarcastic c) Offensive: Not offensive, slightly offensive, very offensive and hateful offensive d) Motivation: Not motivational, motivational 3.2. Dataset The tasks were conducted on the Memotion 3 dataset [5]. It consists of Hindi-English codemixed memes, which were collected from selenium based web crawler and they were gathered from various public platforms like Reddit, Google Images, etc and annotated manually. The dataset consists of 10,000 meme images divided into a train-val-test split of 7000-1500-1500. Each meme is annotated for its sentiment, emotion and intensity of emotion. Images also have their corresponding OCR text extracted with the help of Google Vision APIs and their respective URLs. For more details of the dataset, please refer to [5]. 3.3. Evaluation As mentioned previously, there are three tasks. Scoring is done for each task separately, and separate leaderboards are generated. For each task, we use weighted average F1 score to measure the performance of a model. The participants had access to only train and validation set. They were asked to submit a maximum of 3 submissions on the test set for each task, the best of which was selected as part of the leaderboard. 3.4. Baselines For multi-modal data, it is crucial to take into account both the visual and textual properties, particularly in the case of memes where the context can only be recorded using a mix of both elements. For textual features, we employ a multilingual form of BERT, namely HinglishBERT (BERT base-multilingual-cased) [66], which is tuned on Hinglish data. The trained Vision Transformer (ViT) model provides the visual properties [67]. The Hinglish-BERT embedding is concatenated with the pooled output from the ViT model. After passing through an MLP, the combined features are then categorised in a final classification layer. For more details about the baseline, please refer [5].

Overview of Memotion 3: Sentiment & Emotion
Analysis of Codemixed Hinglish -Task Details

Introduction Everyone who develops apps and services with uses string concatenation. Whenever we need to build a formatted message with different types of data or combine several strings to show helpful information anywhere, we usually enlist the help of string interpolation. C# In the following code snippet, we have a very primitive example of string interpolation int orderAmount = 150;
string orderNumber = "ORDER-13";
Console.WriteLine($"The order with number {orderNumber} has amount of {orderAmount} items"); If we execute the code above, the console shows the following output The order with number ORDER-13 has amount of 150 items But, what is happening under the hood? How does the compiler optimize our code? In general, high-level programming languages offer many abstract programming constructs such as functions, loops, conditional statements, and many other useful things, which help us to be productive and write readable code. Of course, it has a significant drawback — a potential performance decrease. But should developers care about the cost of using such nice abstractions instead of focusing on writing understandable and maintainable code? Ideally, not. For this reason, compilers attempt to optimize our code to improve its performance. For instance, for the code snippet above and using C# 10, the compiler transforms it into the following code: int value = 150;
string value2 = "ORDER-13";
DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(41, 2);
defaultInterpolatedStringHandler.AppendLiteral("The order with number ");
defaultInterpolatedStringHandler.AppendFormatted(value2);
defaultInterpolatedStringHandler.AppendLiteral(" has amount of ");
defaultInterpolatedStringHandler.AppendFormatted(value);
defaultInterpolatedStringHandler.AppendLiteral(" items");
Console.WriteLine(defaultInterpolatedStringHandler.ToStringAndClear()); And when using C# 9, it translates the same code but using method instead: string.Format int num = 150;
string arg = "ORDER-13";
Console.WriteLine(string.Format("The order with number {0} has amount of {1} items", arg, num)); As we can see, in the later C# version, the compiler utilizes a new feature, interpolated string handlers. brilliantly explains in-depth how it works. This article In a nutshell, interpolated string handlers optimize string-building to avoid performance problems with using methods such as unnecessary allocation of object[] on the heap, boxing of arguments, and intermediate string generations. Moreover, performance improvements come almost without any changes in existing codebases. Also, the exciting side of the new strings-building design is the possibility of for particular conditions. string.Format skipping allocating any memory Approach and Results Let’s compare the performance of string concatenation with different options: String.Format String.Concat String.Join String interpolation StringBuilder DefaultInterpolatedStringHandler Enumerable.Aggregate I usually use for benchmarking different solutions. I will benchmark concatenation with a mix of value and reference types and only immutable strings. Benchmark.DotNet //case #1
int orderAmount = 150;
string orderNumber = "ORDER-13"; For the first case, we have the following results: BenchmarkDotNet v0.13.7, Windows 11 (10.0.22621.2134/22H2/2022Update/SunValley2)
AMD Ryzen 7 5700U with Radeon Graphics, 1 CPU, 16 logical and 8 physical cores
.NET SDK 7.0.202
  [Host]   : .NET 7.0.4 (7.0.423.11508), X64 RyuJIT AVX2
  .NET 7.0 : .NET 7.0.4 (7.0.423.11508), X64 RyuJIT AVX2

Job=.NET 7.0  Runtime=.NET 7.0  

|                           Method |      Mean |    Error |   StdDev |   Gen0 | Allocated |
|--------------------------------- |----------:|---------:|---------:|-------:|----------:|
|                     StringFormat |  79.34 ns | 1.002 ns | 0.783 ns | 0.0573 |     120 B |
|              StringInterpolation |  54.01 ns | 0.922 ns | 0.906 ns | 0.0459 |      96 B |
|                     StringConcat |  51.08 ns | 0.208 ns | 0.173 ns | 0.0918 |     192 B |
|                       StringJoin |  74.55 ns | 0.593 ns | 0.526 ns | 0.1032 |     216 B |
|                    StringBuilder |  84.85 ns | 0.311 ns | 0.305 ns | 0.2104 |     440 B |
| DefaultInterpolatedStringHandler |  50.56 ns | 0.431 ns | 0.360 ns | 0.0459 |      96 B |
|              EnumerableAggregate | 150.56 ns | 1.761 ns | 1.648 ns | 0.2716 |     568 B | As we can see, StringFormat is 30% slower and allocates much more memory than using StringInterpolation or DefaultInterpolatedStringHandler, which are the same after compilator optimizations. is the link for the benchmark source code. Here string StringFormat()
{
    int orderAmount = 150;
    string orderNumber = "ORDER-13";
    return string.Format("Order number {0} has {1} items.", orderNumber, orderAmount);
}

string StringInterpolation()
{
    int orderAmount = 150;
    string orderNumber = "ORDER-13";
    return $"Order number {orderNumber} has {orderAmount} items.";
}

string DefaultInterpolatedStringHandler()
{
    int orderAmount = 150;
    string orderNumber = "ORDER-13";
    DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(25, 2);
    defaultInterpolatedStringHandler.AppendLiteral("Order number ");
    defaultInterpolatedStringHandler.AppendFormatted(orderNumber);
    defaultInterpolatedStringHandler.AppendLiteral(" has ");
    defaultInterpolatedStringHandler.AppendFormatted(orderAmount);
    defaultInterpolatedStringHandler.AppendLiteral(" items.");
    return defaultInterpolatedStringHandler.ToStringAndClear();
}

[System.Runtime.CompilerServices.NullableContext(1)]
[CompilerGenerated]
internal static string <<Main>$>g__StringFormat|0_0()
{
    int num = 150;
    string arg = "ORDER-13";
    return string.Format("Order number {0} has {1} items.", arg, num);
}

[System.Runtime.CompilerServices.NullableContext(1)]
[CompilerGenerated]
internal static string <<Main>$>g__StringInterpolation|0_1()
{
    int value = 150;
    string value2 = "ORDER-13";
    DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(25, 2);
    defaultInterpolatedStringHandler.AppendLiteral("Order number ");
    defaultInterpolatedStringHandler.AppendFormatted(value2);
    defaultInterpolatedStringHandler.AppendLiteral(" has ");
    defaultInterpolatedStringHandler.AppendFormatted(value);
    defaultInterpolatedStringHandler.AppendLiteral(" items.");
    return defaultInterpolatedStringHandler.ToStringAndClear();
}

[System.Runtime.CompilerServices.NullableContext(1)]
[CompilerGenerated]
internal static string <<Main>$>g__DefaultInterpolatedStringHandler|0_2()
{
    int value = 150;
    string value2 = "ORDER-13";
    DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(25, 2);
    defaultInterpolatedStringHandler.AppendLiteral("Order number ");
    defaultInterpolatedStringHandler.AppendFormatted(value2);
    defaultInterpolatedStringHandler.AppendLiteral(" has ");
    defaultInterpolatedStringHandler.AppendFormatted(value);
    defaultInterpolatedStringHandler.AppendLiteral(" items.");
    return defaultInterpolatedStringHandler.ToStringAndClear();
} The curious observation is that the use of is slower than , but actually, starts to show a drastically better performance in multiple concatenation statements. StringBuilder string.Format StringBuilder [Benchmark]
public string StringBuilder()
{
    var sb = new StringBuilder();
    for (int i = 0; i < 100; i++)
    {
        sb.Append(i);
    }
    return sb.ToString();
}

[Benchmark]
public string StringConcat()
{
    string result = string.Empty;
    for (int i = 0; i < 100; i++)
    {
        result += i;
    }
    return result;
}

[Benchmark]
public string StringInterpolation()
{
    string result = string.Empty;
    for (int i = 0; i < 100; i++)
    {
        result += $"{i}";
    }
    return result;
}

[Benchmark]
public string StringInterpolationHandler()
{
    var handler = new DefaultInterpolatedStringHandler(0, 100);
    for (int i = 0; i < 100; i++)
    {
        handler.AppendFormatted(i);
    }
    return handler.ToStringAndClear();
} BenchmarkDotNet v0.13.7, Windows 11 (10.0.22621.2134/22H2/2022Update/SunValley2)
AMD Ryzen 7 5700U with Radeon Graphics, 1 CPU, 16 logical and 8 physical cores
.NET SDK 7.0.202
  [Host]   : .NET 7.0.4 (7.0.423.11508), X64 RyuJIT AVX2
  .NET 7.0 : .NET 7.0.4 (7.0.423.11508), X64 RyuJIT AVX2

Job=.NET 7.0  Runtime=.NET 7.0  

|                     Method |       Mean |     Error |    StdDev |    Gen0 | Allocated |
|--------------------------- |-----------:|----------:|----------:|--------:|----------:|
|              StringBuilder |   837.6 ns |  16.78 ns |  47.88 ns |  0.6733 |    1408 B |
|               StringConcat | 2,774.6 ns |  55.47 ns | 106.87 ns | 11.3487 |   23736 B |
|        StringInterpolation | 6,534.7 ns | 170.19 ns | 491.05 ns | 11.4594 |   23976 B |
| StringInterpolationHandler |   681.5 ns |  13.69 ns |  33.05 ns |  0.1945 |     408 B | As we can see, the application of completely outperforms and interpolation approaches, but playbacks to DefaultInterpolatedStringHandler in this scenario. StringBuilder string.Concat Now, for completeness, let’s test our second case by only using immutable strings in concatenation. //case #2
string orderAmount = "150";
string orderNumber = "ORDER-13"; After running benchmarks, we have the following results: BenchmarkDotNet v0.13.7, Windows 11 (10.0.22621.2134/22H2/2022Update/SunValley2)
AMD Ryzen 7 5700U with Radeon Graphics, 1 CPU, 16 logical and 8 physical cores
.NET SDK 7.0.202
  [Host]   : .NET 7.0.4 (7.0.423.11508), X64 RyuJIT AVX2
  .NET 7.0 : .NET 7.0.4 (7.0.423.11508), X64 RyuJIT AVX2

Job=.NET 7.0  Runtime=.NET 7.0  

|                           Method |      Mean |    Error |   StdDev |    Median |   Gen0 | Allocated |
|--------------------------------- |----------:|---------:|---------:|----------:|-------:|----------:|
|                     StringFormat |  80.89 ns | 1.662 ns | 1.847 ns |  79.89 ns | 0.0459 |      96 B |
|              StringInterpolation |  44.67 ns | 0.319 ns | 0.283 ns |  44.70 ns | 0.0459 |      96 B |
|                       StringJoin |  48.15 ns | 0.168 ns | 0.141 ns |  48.13 ns | 0.0765 |     160 B |
|                    StringBuilder |  80.18 ns | 1.538 ns | 3.656 ns |  78.35 ns | 0.2104 |     440 B |
| DefaultInterpolatedStringHandler |  46.24 ns | 0.931 ns | 1.108 ns |  46.23 ns | 0.0459 |      96 B |
|              EnumerableAggregate | 135.90 ns | 2.160 ns | 1.686 ns | 135.51 ns | 0.2563 |     536 B | As we can see, using DefaultInterpolatedStringHandler is still the most efficient way to concatenate strings. High-performance logging Logging is crucial for software, offering transparency and aiding in debugging complex failures. In developing low-level libraries or optimizing performance-critical paths, reducing memory allocation is key for enhancing performance. Boxing, the conversion of value types (like int, double, char) to reference types stored on the heap, involves additional work for the Garbage Collector (GC), impacting performance. The standard extension method accepts arguments as objects, which means we often need to log value types such as counts, dates, and numbers. This process can involve boxing, which affects performance. ILogger LogInformation public static void LogInformation(this ILogger logger, string? message, params object?[] args)
{
    logger.Log(LogLevel.Information, message, args);
} To make our lives easier, Microsoft provides set of useful extensions to overcome this disadvantage. LoggerMessage provides the following performance advantages over Logger extension methods: Logger extension methods require "boxing" (converting) value types, such as int, into object. The LoggerMessage pattern avoids boxing by using static Action fields and extension methods with strongly typed parameters. Logger extension methods must parse the message template (named format string) every time a log message is written. LoggerMessage only requires parsing a template once when the message is defined. Under the hood, it utilises predefined functions with generic parameters, which allows runtime to optimise invocation and avoid unnecessary boxing. /// <summary>
/// Creates a delegate which can be invoked for logging a message.
/// </summary>
/// <typeparam name="T1">The type of the first parameter passed to the named format string.</typeparam>
/// <typeparam name="T2">The type of the second parameter passed to the named format string.</typeparam>
/// <typeparam name="T3">The type of the third parameter passed to the named format string.</typeparam>
/// <param name="logLevel">The <see cref="LogLevel"/></param>
/// <param name="eventId">The event id</param>
/// <param name="formatString">The named format string</param>
/// <param name="options">The <see cref="LogDefineOptions"/></param>
/// <returns>A delegate which when invoked creates a log message.</returns>
public static Action<ILogger, T1, T2, T3, Exception?> Define<T1, T2, T3>(LogLevel logLevel, EventId eventId, string formatString, LogDefineOptions? options)
{
    LogValuesFormatter formatter = CreateLogValuesFormatter(formatString, expectedNamedParameterCount: 3);

    void Log(ILogger logger, T1 arg1, T2 arg2, T3 arg3, Exception? exception)
    {
        logger.Log(logLevel, eventId, new LogValues<T1, T2, T3>(formatter, arg1, arg2, arg3), exception, LogValues<T1, T2, T3>.Callback);
    }

    if (options != null && options.SkipEnabledCheck)
    {
        return Log;
    }

    return (logger, arg1, arg2, arg3, exception) =>
    {
        if (logger.IsEnabled(logLevel))
        {
            Log(logger, arg1, arg2, arg3, exception);
        }
    };
} Let us create a simple benchmark to measure two scenarios: standard logging and one utilising LoggerMessage Of course, it will involve logging of value types. First, I use the class to avoid additional overhead produced by logging into the , for instance. NullLogger Console [SimpleJob(RuntimeMoniker.Net80)]
[MarkdownExporterAttribute.GitHub]
[MemoryDiagnoser]
public class Logging
{
    private ILogger _logger = default!;

    private static readonly Action<ILogger, decimal, int, bool, Exception> _logInformation = LoggerMessage.Define<decimal, int, bool>(
        LogLevel.Information,
        new EventId(1, nameof(Logging)),
        "Information message, {0}, {1}, {2}");

    private static readonly Action<ILogger, bool, char, double, Exception> _logDebug = LoggerMessage.Define<bool, char, double>(
        LogLevel.Debug,
        new EventId(1, nameof(Logging)),
        "Information debug, {0}, {1}, {2}");

    private static readonly Action<ILogger, string, int, double, Exception> _logWarning = LoggerMessage.Define<string, int, double>(
        LogLevel.Warning,
        new EventId(1, nameof(Logging)),
        "Information warning, {0}, {1}, {2}");

    [GlobalSetup]
    public void Setup()
    {
        var loggerFactory = NullLoggerFactory.Instance;
        _logger = loggerFactory.CreateLogger<Logging>();
    }

    [Benchmark]
    public void LogInformation_WithMultipleValueTypes()
    {
        _logger.LogInformation("Information message, {0}, {1}, {2}", 15m, 137, true);
        _logger.LogDebug("Information debug, {0}, {1}, {2}", true, 'o', 150e6d);
        _logger.LogWarning("Information warning, {0}, {1}, {2}", "test", 9, 13.1d);
    }

    [Benchmark]
    public void LoggerMessage_WithMultipleValueTypes()
    {
        _logInformation(_logger, 15m, 137, true, null);
        _logDebug(_logger, true, 'o', 150e6, null);
        _logWarning(_logger, "test", 9, 13.1d, null);
    }
} The results indicate that performs better than the standard logging extensions. LoggerMessage BenchmarkDotNet v0.13.12, Windows 11 (10.0.22631.3296/23H2/2023Update/SunValley3)
13th Gen Intel Core i7-13700HX, 1 CPU, 24 logical and 16 physical cores
.NET SDK 8.0.101
  [Host]   : .NET 8.0.1 (8.0.123.58001), X64 RyuJIT AVX2 [AttachedDebugger]
  .NET 8.0 : .NET 8.0.1 (8.0.123.58001), X64 RyuJIT AVX2

Job=.NET 8.0  Runtime=.NET 8.0

| Method                                | Mean       | Error     | StdDev     | Median     | Gen0   | Allocated |
|-------------------------------------- |-----------:|----------:|-----------:|-----------:|-------:|----------:|
| LogInformation_WithMultipleValueTypes | 176.656 ns | 7.0850 ns | 20.7790 ns | 182.843 ns | 0.0219 |     344 B |
| LoggerMessage_WithMultipleValueTypes  |   4.574 ns | 0.3076 ns |  0.9069 ns |   4.939 ns |      - |         - | And the same but with the Console [GlobalSetup]
public void Setup()
{
    var loggerFactory = LoggerFactory.Create(builder => builder.AddConsole());
    _logger = loggerFactory.CreateLogger<Logging>();
} As we can see here, the Logger message also performs better while allocating 37% less memory. BenchmarkDotNet v0.13.12, Windows 11 (10.0.22631.3296/23H2/2023Update/SunValley3)
13th Gen Intel Core i7-13700HX, 1 CPU, 24 logical and 16 physical cores
.NET SDK 8.0.101
  [Host]   : .NET 8.0.1 (8.0.123.58001), X64 RyuJIT AVX2 [AttachedDebugger]
  .NET 8.0 : .NET 8.0.1 (8.0.123.58001), X64 RyuJIT AVX2

Job=.NET 8.0  Runtime=.NET 8.0

| Method                                | Mean     | Error   | StdDev  | Allocated |
|-------------------------------------- |---------:|--------:|--------:|----------:|
| LogInformation_WithMultipleValueTypes | 326.8 us | 6.45 us | 6.90 us |     955 B |
| LoggerMessage_WithMultipleValueTypes  | 309.9 us | 6.14 us | 8.19 us |     608 B | Conclusion With C# 10 and higher, use string interpolation instead of , it allocates much less extra memory besides the final string string.Format Use DefaultInterpolatedStringHandler or StringBuilder in multiple concatenation statements Try to avoid using directly since it could reduce code readability DefaultInterpolatedStringHandler in scenarios like , usually for hot paths and libraries Develop custom string interpolation handler Debug.Assert Utilise in hot path scenarios or low-level libraries to avoid unnecessary allocation due to boxing of value types LoggerMessage See you next time!

A Detailed Guide to String Concatenation in .NET

The Devil Is In The (Crypto) Details:
Finding Truth in the Controversies

দ্য ডেভিল ইজ ইন দ্য (ক্রিপ্টো) বিবরণ:
বিতর্কের মধ্যে সত্যের সন্ধান করা

Der Teufel steckt in den (Krypto-)Details:
Die Wahrheit in den Kontroversen finden

El diablo está en los detalles (cripto):
Encontrar la verdad en las controversias

Le diable est dans les détails (de la cryptographie) :
Trouver la vérité dans les controverses

द डेविल इज़ इन द (क्रिप्टो) विवरण:
विवादों में सत्य की खोज

The Devil Is In The (Crypto) 詳細:
論争の中で真実を見つける

The Devil Is In The (Crypto) 세부정보:
논쟁에서 진실 찾기

O diabo está nos detalhes (criptografados):
Encontrando a verdade nas controvérsias

Дьявол кроется в (криптовалюте) Подробности:
Как найти истину в спорах

Şeytan (Kriptoda) Ayrıntılarda:
Tartışmalarda Gerçeği Bulmak

Chi tiết về ác quỷ ở trong (tiền điện tử):
Tìm kiếm sự thật trong các cuộc tranh cãi

魔鬼就在（加密货币）详细信息：
在争议中寻找真相

ERIK ADOLPH vs. Uber Court Filing, retrieved on July 17, 2023, is part of . You can jump to any part in this filing . This is part 4 of 15. HackerNoon’s Legal PDF Series here III. Against this backdrop, we consider whether an aggrieved employee who has been compelled to arbitrate individual claims “premised on Labor Code violations actually sustained by” the plaintiff (Viking River, supra, 596 U.S. at p. __ [142 S.Ct. at p. 1916]; see Lab. Code, § 2699, subd. (a)) maintains statutory standing to pursue non-individual “PAGA claims arising out of events involving other employees” (Viking River, at p. __ [142 S.Ct. at p. 1916]) in court. The high court concluded that a PAGA plaintiff loses standing in this situation: “[A]s we see it, PAGA provides no mechanism to enable a court to adjudicate non-individual PAGA claims once an individual claim has been committed to a separate proceeding. Under PAGA’s standing requirement, a plaintiff can maintain non-individual PAGA claims in an action only by virtue of also maintaining an individual claim in that action. See Cal. Lab. Code Ann. §§ 2699(a), (c). When an employee’s own dispute is pared away from a PAGA action, the employee is no different from a member of the general public, and PAGA does not allow such persons to maintain suit. See Kim, 9 Cal.5th at 90 (‘PAGA’s standing requirement was meant to be a departure from the “general public” . . . standing originally allowed’ under other California statutes). As a result, Moriana lacks statutory standing to continue to maintain her non-individual claims in court, and the correct course is to dismiss her remaining claims.” (Viking River, supra, 596 U.S. at p. __ [142 S.Ct. at p. 1925].) Because “[t]he highest court of each State . . . remains ‘the final arbiter of what is state law’ ” (Montana v. Wyoming (2011) 563 U.S. 368, 378, fn. 5), we are not bound by the high court’s interpretation of California law. (See Viking River, supra, 596 U.S. at pp. [142 S.Ct. at p. 1925] (conc. opn. of Sotomayor, J.) [“Of course, if this Court’s understanding of state law is wrong, California courts, in an appropriate case, will have the last word.”].) And although the high court’s interpretations may serve as persuasive authority in cases involving a parallel federal constitutional provision or statutory scheme (cf., e.g., Raven v. Deukmejian (1990) 52 Cal.3d 336, 353; People v. Teresinski (1982) 30 Cal.3d 822, 835–836), Viking River does not interpret any federal provision or statute similar to PAGA. – Where, as here, a cause of action is based on a state statute, standing is a matter of statutory interpretation. (Kim, supra, 9 Cal.5th at p. 83.) “We review questions of statutory construction de novo.” (California Building Industry Assn. v. State Water Resources Control Bd. (2018) 4 Cal.5th 1032, 1041.) Continue Reading . Here About HackerNoon Legal PDF Series: We bring you the most important technical and insightful public domain court case filings. This court case S274671 retrieved on September 22, 2023, from is part of the public domain. The court-created documents are works of the federal government, and under copyright law, are automatically placed in the public domain and may be shared without legal restriction. courts.ca.gov

How Can a PAGA Plaintiff Lose Standing? The Court Goes Into Detail in the Uber Lawsuit

PARAG AGRAWAL VIJAYA GADDE, and NED SEGAL v. twitter Court Filing, retrieved on April 10, 2023 is part of . You can jump to any part in this filing . This is part 36 of 38. HackerNoon’s Legal PDF Series here EXHIBIT M - Via E - Mail - March 23, 2023 Via E - Mail and FedEx Morgan, Lewis & Bockius LLP One State Street Hartford, CT 06103 Attn: Michael D. Blanchard michale.blanchard@morganlewis.com Request for Indemnification and Advancement Dear Mr. Blanchard: I write on behalf of Vijaya Gadde, Ned Segal, Parag Agrawal, and Kayvon Beykpour, former officers of Twitter, Inc. (the "Company"). I received your letter on behalf of the Company dated March 17, 2023, wherein you acknowledge my prior correspondence to the Company concerning my client's rights to indemnification and advancement. Your letter states that you are reviewing my letters dated January 13, 2023, March 3, 2023, and March 16, 2023. In aid of that review, attached hereto are subsequent invoices related to the Proceedings described previously. Due to their continued involvement in these Proceedings, certain of my clients have incurred the following additional Expenses since the time of my last letter: Ms. Gadde has incurred an additional $881.92 in Expenses related to the D'Ambly Lawsuit. D'Ambly Lawsuit: : Mr. Segal, Mr. Agrawal, Ms. Gadde, and Mr. Beykpour have incurred an additional $ 23,379.50 in Expenses related to the Securities Class Action. Securities Class Action Ms. Gadde has incurred an additional $578,942.81 in connection with her testimony before the House Committee on Oversight and Reform of the 118th Congress. Inquiries: As I stated previously, there can be no legitimate dispute that my clients are involved in these Proceedings by reason of the fact that each was an officer of the Company, and therefore that the Company is obligated to advance the Expenses we have submitted. I trust that you also are aware that, pursuant to Section 5 of each of my clients' respective Director & Officer Indemnification Agreement, the Company is required to advance all Expenses "within thirty (30) days after the receipt by the Company of a statement. . . requesting such advance or advances." We look forward to your client's timely compliance with its obligations. While you have indicated that you will respond to my letters "in due course," I respectfully request a call at your earliest convenience to discuss the Company's obligations, and particularly to hear whether there is any basis on which the Company anticipates denying advancement to, or indemnification of, my clients. Please let me know your availability this week or early next week. Very truly yours, David L. Anderson Encl. cc: James Heyworth, Sidley Austin LLP Sheila A.G. Armbrust, Sidley Austin LLP Amy M. Dudash, Morgan, Lewis & Bockius LLP Continue Reading . Here About HackerNoon Legal PDF Series: We bring you the most important technical and insightful public domain court case filings. This court case 2023-0409 retrieved on October 4, 2023, from is part of the public domain. The court-created documents are works of the federal government, and under copyright law, are automatically placed in the public domain and may be shared without legal restriction. int.nyt.com

Details of the Twitter Lawsuit: Letters Between Both Sides' Lawyers

Authors: (1) Dominic Petrak, UKP Lab, Department of Computer Science, Technical University of Darmstadt, Germany; (2) Nafise Sadat Moosavi, Department of Computer Science, The University of Sheffield, United Kingdom; (3) Ye Tian, Wluper, London, United Kingdom; (4) Nikolai Rozanov, Wluper, London, United Kingdom; (5) Iryna Gurevych, UKP Lab, Department of Computer Science, Technical University of Darmstadt, Germany. Table of Links Abstract & Introduction Related Work Datasets Examined Manual Error Type Analysis and Taxonomies Automatic Filtering for Potentially Relevant Dialogs Statistical Analysis Evaluation and Experiments Discussion Conclusion, Limitation, Acknowledgments, and References A Integrated Error Taxonomy – Details B Error-Indicating Sentences And Phrases C Automatic Filtering – Implementation D Automatic Filtering – Sentence-Level Analysis E Task-Oriented Dialogs – Examples F Effectiveness Of Automatic Filtering – A Detailed Analysis G Inter-Annotator Agreement – Detailed Analysis H Annotation Guidelines I Hyperparameters and Baseline Experiments J Human-Human Dialogs – Examples G Inter-Annotator Agreement – Detailed Analysis This section gives more insights on the interannotator agreement. All additional annotators that participated in this study were non-native speakers. They were experts from our lab with sound English skills and NLP background. We did not select them based on specific criteria; they participated voluntarily. Accordingly, they were not paid extra for this, since they did the annotations during their working hours. For annotation, we did not use any specific tool. We provided the annotators with dialogs in json format and asked them to do the annotations directly in the respective files. See Section H for the annotation guidelines. Table 13 shows the inter-annotator agreement for each dataset using our modified Integrated Error Taxonomy. In the case of human-human dialogs, the overall agreement is rather low (except for Persona Chat (Zhang et al., 2018)). We find that errors are hard to identify in these dialogs, as humans rather suggest disagreements instead of accusing the partner of a mistake. This is also reflected in the user response type agreement since it depends on the error type annotation. However, Persona Chat seems to be different (according to Table 8). We attribute this to the dialog type, which is open-domain, where we find that humans react harshly and accusing to errors in system utterances, resulting in more direct feedback that is easier to identify. Table 14 shows the inter-annotator agreement for each dataset using the original Integrated Error Taxonomy as proposed by Higashinaka et al. (2021). Using this taxonomy deteriorates the interannotator agreement. This is most obvious in case of MWoZ (Budzianowski et al., 2018) and PC (Zhang et al., 2018), which are both humanhuman datasets. A detailed analysis revealed that this is mostly due to over-specialized error types which were merged in our modified taxonomy, such as ignore expectation and ignore request, I9 and I6 in the original taxonomy (Table 2). Another reason are the newly added error types, such as factually incorrect, E5 (Table 4), which were not covered in the original taxonomy, but occur in the dialogs. This paper is under CC BY-NC-SA 4.0 DEED license. available on arxiv

A Detailed Analysis of Inter-Annotator Agreement

Authors: (1) Dominic Petrak, UKP Lab, Department of Computer Science, Technical University of Darmstadt, Germany; (2) Nafise Sadat Moosavi, Department of Computer Science, The University of Sheffield, United Kingdom; (3) Ye Tian, Wluper, London, United Kingdom; (4) Nikolai Rozanov, Wluper, London, United Kingdom; (5) Iryna Gurevych, UKP Lab, Department of Computer Science, Technical University of Darmstadt, Germany. Table of Links Abstract & Introduction Related Work Datasets Examined Manual Error Type Analysis and Taxonomies Automatic Filtering for Potentially Relevant Dialogs Statistical Analysis Evaluation and Experiments Discussion Conclusion, Limitation, Acknowledgments, and References A Integrated Error Taxonomy – Details B Error-Indicating Sentences And Phrases C Automatic Filtering – Implementation D Automatic Filtering – Sentence-Level Analysis E Task-Oriented Dialogs – Examples F Effectiveness Of Automatic Filtering – A Detailed Analysis G Inter-Annotator Agreement – Detailed Analysis H Annotation Guidelines I Hyperparameters and Baseline Experiments J Human-Human Dialogs – Examples F Effectiveness Of Automatic Filtering – A Detailed Analysis For the statistical analysis in Section 6, we consider 20 dialogs from each similarity range, i.e., 50%−60%, 60%−70%, 70%−80%, 80%−90%, 90% − 100% (if available, see also Appendix D) for each dataset examined. As the data in the upper ranges (80%−100%) is scarce in case of WoW (Dinan et al., 2019), PC (Zhang et al., 2018), and BABI (Bordes et al., 2017), the filtered dialogs consists only of 555 dialogs (instead of 600 like the randomly selected dialogs). Table 12 shows the errors annotated for the statistical analysis with respect to the similarity ranges identified by automatic filtering (meaning that each dialog contains at least one user response with a sentence identified to be similar to at least one error-indicating sentence in this similarity range). Overall (O) represents the number of dialogs randomly sampled from the respective similarity range, and Error (E) represents the number of dialogs identified in our manual analysis to contain an error in a system utterance. Overall, only 58 dialogs of the randomly selected ones (9.6%) contain errors. In the case of automatic filtering, we observe 130 of such cases. Therefore, automatic filtering shows to facilitate the process of identifying errors in system utterances. Even if the number of identified errors is overall low, most errors are identified in the range of 60% −100%, excluding the densest section in case of MWoZ (Budzianowski et al., 2018), SGD (Rastogi et al., 2020), PC and WoW, 50% − 60% (see also Figure 2). This paper is under CC BY-NC-SA 4.0 DEED license. available on arxiv

Stories, News & Mentions about DETA

Deta’s Stories on HackerNoon