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

Deta

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

DETA

deta.sh

-- employees

Since n.d.

COMPANY RANKING

DETA

EVERGREEN INDEX #3472

Representing this company? Click here to claim and customize this page!

Deta WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!

DETA

deta.sh

-- employees

Since n.d.

COMPANY RANKING

DETA

EVERGREEN INDEX #3472

RELATED COMPANIESRANK

STORIES ABOUT DETA

Representing this company? Click here to claim and customize this page!

Deta WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!