Big Data Science

How to read Parquet files
The Apache Parquet format is widely used in Big Data due to its column-wise storage and efficient compression. It allows you to quickly read the data you want from a specific column instead of reading a full row and saves time. However, not every application system can read binary Parquet files. It is often necessary to convert Parquet files to CSV or TXT format before opening them, for example, in MS Excel or Power BI, which are often used in the work of a DS specialist. In this case, the Python pandas library will help with the built-in read_parquet() function for reading data from a Parquet file into a dataframe. The dataframe can then be saved to a CSV file using the to_csv() method and opened in almost any office spreadsheet editor.
https://medium.com/@i.m.mak/workaround-for-reading-parquet-files-in-power-bi-e2d060abcb80

Visual Genome: the most labeled dataset
👁Scientists at Stanford University have collected the most annotated dataset with over 100,000 images. In total, the dataset contains almost 5.5 million object descriptions, attributes and relationships. You don't even have to download the dataset, but get the data you need by accessing the RESTful API endpoint using the GET-method. Despite the fact that the latest updates to the dataset are dated 2017, this is an excellent data set for training models in typical ML problems, from recognizing generated data using graph algorithms.
https://visualgenome.org/api/v0/api_home.html

🙌🏻XLS-R is a new set of ML models from Facebook AI
The PyTorch team from Facebook have published XLS-R, a set of large-scale models for self-study of cross-language speech representation based on wav2vec 2.0. The models were trained in 128 languages for over 400 thousand hours of unlabeled speech. Thanks to fine tuning, the models show a high level of speech recognition and are excellent for translation, understanding and language identification tasks. The training data was taken from a variety of sources, including audiobooks and court records. XLS-R neural network models contain more than 2 billion parameters and are multilingual. Moreover, testing has shown that teaching several languages at once increases the efficiency of neural networks. You can download XLS-R from Github right now.
https://github.com/pytorch/fairseq/tree/main/examples/wav2vec/xlsr

☃️🎄❄️TOP-10 the most interesting DS-conferences all over the world in December 2021
1. 2 Dec – TechCrunch and iMerit ML DataOps Summit https://techcrunch.com/events/imerit-ml-dataops-summit/
2. 6-7 Dec – Scientific Data Analysis at Scale (SciDAS) Cloud Computing Workshop. Chapel Hill, NC, USA & Virtual https://renci.github.io/sbdh-scidas-workshop/
3. 6-10 Dec – The Analytics Engineering Conference https://coalesce.getdbt.com/
4. 7-10 Dec - IEEE ICDM 2021: 21st IEEE Int. Conference on Data Mining, Auckland, New Zealand https://icdm2021.auckland.ac.nz/
5. 7 Dec - Chief Data & Analytics Officer, Nordics - Think Tanks, by Corinium. Join The Nordic Region's Most Innovative Data & Analytics Leaders. Online https://cdao-nordics.coriniumintelligence.com/
6. 7-8 Dec - MENA Conversational AI Summit 2021, Virtual https://menaconversationalai.com/
7. 8 Dec - Data Points Summit | Manufacturing, Retail & CPG by Grid Dynamics. Online https://datapoints.griddynamics.com/
8. 9 Dec – Augment - Cloud Data Warehousing Summit, free virtual event https://hevodata.com/events/summit/how-to-migrate-setup-and-scale-a-cloud-data-warehouse
9. 14 Dec - Data Reliability Engineering Conference 2021, One full day of reliability standards and innovation, Free Registration, online https://drecon.org/
10. 15-18 Dec - IEEE Int. Conf. on Big Data (IEEE BigData 2021). Orlando, FL, USA https://bigdataieee.org/BigData2021/index.html

🥁Data engineering for Data Science: SynapseML by Microsoft
Microsoft has adapted Apache Spark for the tasks of data engineers and DS specialists, released SynapseML - a framework for creating scalable ML pipelines. This open source library was previously called MMLSpark. SynapseML powered by SparkML to the Spark ecosystem of deep learning and data analysis, seamless ML pipeline transformation tools with Open Neural Network Exchange (ONNX), LightGBM, Cognitive Services, Vowpal Wabbit, and OpenCV. This allows you to create powerful and highly scalable predictive and analytical models for a variety of data sources.
It is noteworthy that SynapseML is able to work with untagged datasets thanks to API methods of ready-made AI services for quickly solving typical ML tasks. SynapseML requires Scala 2.12, Spark 3.0+, and Python 3.6+. The framework allows you to write code in any Spark-compatible language: Python, Scala, R, Java, .NET, and C #. Over the HTTP protocol, users can embed any web service into their SparkML models, and the clustered nature of Spark allows ML projects to scale.
https://microsoft.github.io/SynapseML/
https://github.com/microsoft/SynapseML

💥Apache Spark on Google Colab? Installing PySpark on DS Cloud
Apache Spark is one of the most demanded computational frameworks in the Big Data field. With its clustered architecture and in-memory MapReduce jobs, it quickly processes huge amounts of data. Spark has an API for the popular DS Python language, PySpark, and automatically parallelizes code generated on the local machine to all nodes in the cluster. But what if you don't have a cluster and need to process a lot of data?
Cloud solutions will help - Google Colab, where you can install Spark. First you need to download Java, because the framework is written in Scala and runs on JVM:
!apt-get install openjdk-8-jdk-headless -qq > /dev/null
Then you should download the Spark framework itself from the official website of the Apache Software Foundation, along with Hadoop
!wget -q https://www-us.apache.org/dist/spark/spark-3.1.2/spark-3.1.2-bin-hadoop2.7.tgz
Unzip the downloaded tgz-file
!tar xf spark-3.1.2-bin-hadoop2.7.tgz
The next step is to install the findspark library to find Spark on the system and import it.
!pip install -q findspark
Then you need to set the path to the Colab environment to run PySpark there:
import os
os.environ["JAVA_HOME"] = "/usr/lib/jvm/java-8-openjdk-amd64"
os.environ["SPARK_HOME"] = "/content/spark-3.1.2-bin-hadoop2.7"
To find Spark on the system, import findspark and use the findspark.init() method. The findspark.find() method will help you find out where Spark is installed:
import findspark
findspark.init()
findspark.find()
Finally, you can import the Spark - SparkSession from PySpark.sql and create an entry point to the framework, optionally specifying the application name in the appName (“”) configuration parameter
from pyspark.sql import SparkSessionspark= SparkSession \
.builder \
.appName("Spark Application Name") \
.getOrCreate()
https://medium.com/geekculture/how-to-get-your-spark-installation-right-every-time-on-colab-218d57b6091d

🐱Visualizing Temporal Changes of Categorical Data: PyCatFlow vs RankFlow
Sometimes a Data Scientist needs to visualize ranked lists over time, such as changes in search results for queries on Google or YouTube. To do this, you can use RankFlow - a useful tool with a minimalistic UI and a rather cumbersome data preparation process. RankFlow allows you to compare ranked listings over time. It requires that the input tabular data be organized so that each column represents a ranked list. Each ranked list can be supplemented with weights, adding another level of information to the data. For example, for YouTube search results, you can take views, upvotes, or upvotes ratio. Each column in a data table is represented as a stack of nodes, ordered according to rank in a given dataset. In addition, identical nodes are connected between columns. This highlights data continuity and changes, allowing pattern analysis.
Building a RankFlow visualization from this data requires modifying the dataset. For each version of the API, there must be a column containing a ranked list of permissions that are not ordered by any relevance metric. Therefore, ordering a RankFlow chart is a design decision, meaning items can be sorted alphabetically, by frequency in the dataset, or based on additional data.
In practice, adapting the data to the required RankFlow data structure is quite tedious. To speed up the pre- and post-processing of charts, you can write your own Python script that processes the XML data in the SVG file generated by RankFlow. An alternative is PyCatFlow, a visualization tool similar to RankFlow that works well for temporal data without explicit ranking information, but with potential additional categorical data. PyCatFlow is an open-source Python package that can be downloaded freely from Github.
https://medium.com/@bumatic/pycatflow-visualizing-categorical-data-over-time-b344102bcce2
https://github.com/bumatic/PyCatFlow

• Non-negative Matrix Factorization (NMF) - Non-negative matrix factorization, an alternative approach to decomposition that assumes that the data and components are non-negative. NMF is an uncontrolled linear dimensionality reduction technique. In NMF, the original data (feature matrix) is split into multiple matrices (i.e., factorized) representing the hidden relationship between observations and their characteristics. NMF can be connected instead of PCA when the data matrix does not contain negative values. NMF does not provide an explained variance like PCA and other methods, so the best way to find the optimal value for n_components is to try a range of values.
• Truncated Singular Value Decomposition (TSVD) - Truncated singular value decomposition is similar to PCA. This method performs linear dimensionality reduction using a truncated singular value decomposition. Unlike PCA, this estimator does not center the data before computing the singular value decomposition and can work efficiently with sparse matrices.
https://medium.com/@deepak.engg.phd/dimensionality-reduction-with-scikit-learn-ee5d2b69225b

🙌🏻Principal Component Analysis: 7 Methods for Dimension Reduction in Scikit-Learn
One of the main problems of machine learning on large datasets is the huge size of the computational vectors. Therefore, methods of dimensionality reduction to reduce the number of variables are very relevant. This method is Principal Component Analysis (PCA), the essence of which is to reduce the dimension of the dataset, while retaining as much "variability" as possible, i.e. statistical information.
PCA is a statistical method of converting high-dimensional data into low-dimensional data by choosing the most important features that collect as much information about the dataset as possible. Features are selected based on the variance they cause in the output. The trait that causes the most variance is the first major component. The trait responsible for the second largest variance is considered the second main component, etc. It is important that the main components are not related to each other in any way. In addition to speeding up ML algorithms, PCA allows you to visualize data by projecting it into a lower dimension in order to display it in 2D or 3D space.
The popular Python library Scikit-learn includes the sklearn.decomposition.PCA module, which is implemented as a transformer object for multiple components in the fit () method. It can also be used for new data to project onto these components. To use the PCA method in the Scikit-Learn library, there are 2 steps:
1. Initialize the PCA class by passing the required number of components to the constructor;
2. invoke the fitting methods, and then transform them, passing them a feature set. The transform method returns the specified number of base components.
Scikit-learn supports several variations of the PCA method:
• Kernel Principal Component Analysis (KPCA) is a nonlinear dimensionality reduction method using the kernel. The PCA kernel was developed to help classify data whose decision boundaries are described by a non-linear function. The idea is to move into a higher-dimensional space in which the decision-making boundary becomes linear. The sklearn.decomposition module has different kernels: linear, polynomial (poly), Gaussian radial basis function (rbf), sigmoid (sigmoid '), etc. The default is linear, which is suitable if the data is linear separable.
• Sparse PCA - A sparse version of PCA, the purpose of which is to extract a set of sparse components that best recovers data. Typically, PCA extracted components have extremely dense expressions, i.e. nonzero coefficients as linear combinations of the original variables. This makes it difficult to interpret the results. In practice, real principal components can be more naturally represented as sparse vectors, for example, in face recognition, they can display parts of faces.
• Incremental Principal Component Analysis (IPCA) - Incremental PCA method when the dataset to be decomposed is too large to fit in memory. IPCA constructs a low-rank approximation for the input data using an amount of memory that is independent of the size of the input sample. It still depends on the input features, but changing the packet size allows you to control the memory usage.
• Fast Independent Component Analysis (ICA) - Fast independent PCA is used to evaluate sources with noisy measurements and reconstruct sources, since classic PCA does not work with non-Gaussian processes.
• Linear Discriminant Analysis (LDA) - Linear Discriminant Analysis, like classical PCA, is a linear transformation method. But the PCA is not monitored, i.e. ignores class labels, and LDA is supervised machine learning that is used to distinguish between two classes or groups. LDA is suitable for controlled dimensionality reduction by projecting input data into linear subspace from directions that maximize separation between classes. The dimension of the output is necessarily less than the number of classes. In scikit-learn, LDA is implemented using LinearDiscriminantAnalysis, where the n_components parameter specifies the number of functions to return.

🕸🐅Over 50 New Graph Algorithms in TigerGraph: Fall 2021 Release
TigerGraph is a popular fast and scalable graph database with massively parallel processing and ACID transaction support, making it the fastest and most scalable graphics platform. Thanks to its efficient data compression and MPP architecture, it can analyze huge amounts of information in real time. And the internal query language GSQL is very similar to standard SQL, familiar to every analyst.
October 2021 release includes 50 new algorithms, for example, embedded graphs node2vec and FastRP, similarity algorithms ("Nearest Neighbor Approximation", "Euclidean Similarity", "Overlap Similarity" and "Pearson Similarity"), structural similarity algorithms for predicting topological relationships and random path algorithms. In the first half of 2022, the developers promise to add neural networks and other ML methods to build analytical pipelines on graphs. Despite the fact that TigerGraph is positioned as a powerful enterprise solution, the source code of this system is open and available for free download from Github.
https://www.tigergraph.com/blogs/about-tigergraph/graph-data-science-library/
https://github.com/tigergraph

🌏Digital Twin of Earth from NVIDIA
To prevent climate disasters, NVIDIA is set to build the world's most powerful AI supercomputer for predicting climate change. This system will create a digital twin of the Earth in the Universe and will become an analogue of Cambridge-1, the world's most powerful supercomputer with artificial intelligence for medical research. By combining three technologies: GPU-accelerated computing, deep learning on neural networks, and AI supercomputers with a lot of observable and model data, scientists and engineers are set to achieve accurate simulations of physical, biological and chemical processes on Earth. This will help shape early warnings for the adaptation and resilience of urban infrastructure so that people and countries can act quickly to prevent climate disasters.
https://blogs.nvidia.com/blog/2021/11/12/earth-2-supercomputer/

📝👀Fastparquet: Reading Parqufet Files with Python
Apache Parquet is a binary column-oriented storage format originally created for the Hadoop ecosystem. Thanks to its concise and efficient column-wise representation of data, it is very popular in the Big Data world. However, reading the data in Parquet format is not an easy task. PySpark can handle this, of course, but not every Data Scientist works with data in Apache Spark. This is where fastparquet comes in, a Python implementation of the Parquet format used by Dask, Pandas, and others to deliver high performance with a small distribution size and small codebase. Fastparquet depends on a set of Python libraries (numpy, pandas, cramjam, fsspec), so they should be installed beforehand.
After installation via the PIP package manager (pip install fastparquet) or from Github (pip install git + https: //github.com/dask/fastparquet), the contents of the Parquet file can be easily transferred to the dataframe in your usual DS-IDE as Jupiter Notebook:
from fastparquet import ParquetFile
pf = ParquetFile('myfile.parq')
df = pf.to_pandas()
df2 = pf.to_pandas(['col1', 'col2'], categories=['col1'])

Or write a dataframe to a Parquet file, specifying the number of logical segments, compression codec and data scheme:
from fastparquet import write
write('outfile.parq', df)
write('outfile2.parq', df, row_group_offsets=[0, 10000, 20000],
compression='GZIP', file_scheme='hive')

https://github.com/dask/fastparquet
https://www.anaconda.com/blog/whats-new-with-fastparquet
https://blog.datasyndrome.com/using-the-python-ml-stack-inside-pyspark-de1223942c32
https://fastparquet.readthedocs.io/en/latest/

😜ML for child protection
In the United States, one in seven children has been abused or neglected in the past year. US Child Protection Agencies receive several million reports of alleged neglect or abuse each year. Therefore, some agencies are implementing ML to help professionals review cases and determine which ones should be investigated next. But these ML models are useless if users don't understand and trust their results.
So a study from MIT and others has developed a visual analytics tool that uses bar charts to show how specific factors in a case affect the predicted risk of a child being homeless over the next two years. This risk assessment is based on over 100 demographic and historical factors, including parental age and criminal record. Having tested the created solution, the developers drew conclusions about the need to improve the visualization and interpretability of forecasts in order to avoid dangerous distortions in making important decisions.
https://news.mit.edu/2021/machine-learning-high-stakes-1028

🧐AI predicts how old children are. How safe is it?
Today, any content is usually limited by age, indicating the minimum number of years of its potential consumer. Everyone knows the labeling of films 18+. And in most social networks, users over the age of 13 can independently create accounts. Unsurprisingly, facial recognition technologies are being used to determine the age of content consumers or users. Looking further, AI can predict what a person will look like in old age: remember the recent boom in FaceApp.
Likewise, Yoti's age solutions have a margin of error of less than 3 years for a range of 6 to 60 years. For users under 25 years of age, the margin of error is less than 1.5 years. In the next few weeks, they will launch in major supermarket chains in the UK, for example, to prevent the sale of alcohol to minors. Yoti trained her neural networks using hundreds of thousands of images of people's faces from their official documents (passports and driver's licenses). Due to the high risk of leakage of such confidential data, other players in the face recognition market say that age verification should, if possible, be done without analyzing the face itself or other biometric data.
https://www.wired.com/story/ai-predicts-how-old-children-are/

🦋Self-Supervised Reversible Reinforcement Learning: A New Approach from Google AI
Reinforcement learning (RL) is great at solving problems from scratch, but it is not easy to train an agent to understand the reversibility of his actions. For example, robots should avoid activities that could damage them. To evaluate the reversibility of an action, one needs practical knowledge and understanding of the physics of the environment in which the RL agent exists. Therefore, Google AI researchers at the NeurIPS 2021 conference present a new way to approximate the reversibility of the actions of RL agents. This approach adds a separate reversibility assessment component to self-directed reinforcement learning from untagged data collected by agents. The model can be trained online (with the RL agent) or offline (from the interaction dataset) to guide RL policies towards reversible behavior. This can significantly improve the performance of RL agents when performing multiple tasks.
The reversibility component added to the RL procedure is extracted from interactions and is a model that can be trained separately from the agent itself. The model is trained on its own and does not require data markup indicating the reversibility of actions: the model itself learns which types of actions tend to be reversible from the context of the training data. This takes into account the probability of occurrence of events and priority as a proxy measure of the true reversibility, which can be learned from the dataset of interactions, even without rewarding the RL agent.
This method allows RL agents to predict reversibility of action by learning to simulate the temporal order of randomly selected trajectory events, resulting in better exploration and control. The method is self-checking, i.e. does not require prior knowledge of reversibility, which is suitable for different environments.
https://ai.googleblog.com/2021/11/self-supervised-reversibility-aware.html

✈️Optuna: How to Automate Hyperparameter Tuning
Tuning the hyperparameters of an ML model takes a lot of time and effort. To simplify this task, you can use special frameworks, one of which is Optuna. Launched in 2019, this platform has the following advantages:
• compatibility with PyTorch, Chainer, TensorFlow, Keras, MXNet, Scikit-Learn, XGBoost, LightGBM and other ML frameworks;
• work in an understandable DS-language using conditional expressions, loops and Python syntax;
• the ability to handle continuous hyperparameter values by tuning alpha and lambda regularization to any floating point values within a given range;
• use of Bayesian selection algorithms with the ability to remove the obviously losing space of the given hyperparameters from the analysis in order to speed up the optimization;
• parallelization of the search for hyperparameters over several threads or processes without changing the code;
• works faster than analogs (RandomSearch, GridSearch, hyperopt, scikit-optimize);
• detailed documentation.
https://optuna.org/
https://towardsdatascience.com/kagglers-guide-to-lightgbm-hyperparameter-tuning-with-optuna-in-2021-ed048d9838b5

🚀Simple interpolation in Scipy instead of complex optimization
SciPy is a set of math algorithms and helper functions built on an extension of the NumPy Python library. It adds many high-level commands and classes for manipulating and visualizing data, allowing a DS specialist to get away with a regular Python code development environment without complex math systems like MATLAB, IDL, Octave, R-Lab, and SciLab.
For example, interpolation of experimental data in complex scientific or business research. Having obtained the interpolation function from Scipy, you can use it in further calculations. This is useful when additional collection and experimentation is expensive or time-consuming, such as semiconductor development, chemical process optimization, production planning, etc.
Interpolation will help to conduct simulations with datasets where data points are collected at a large interval. For example, you can create an interpolation function using linear, quadratic, or cubic splines and run the interpolation function to evaluate the results of an experiment or simulation on a dense mesh.
This method does not guarantee the best results in all situations, but it is suitable for most real-life situations. Despite the fact that interpolation requires smoothness (continuity) of the function, this assumption can be applied to most real ones, which are not too jumpy, but rather smooth for interpolation methods.
Scipy interpolation routines work in both 2D and 1D cases. For example, you can get a smooth interpolated 2D surface from sparse data using Scipy interpolation, creating a 4900-point matrix from 400 actual data points.
In Scipy, the scipy.interpolate package is responsible for interpolation, which contains spline functions and classes, one-dimensional and multidimensional interpolation classes, Lagrange and Taylor polynomial interpolators, and wrappers for the FITPACK and DFITPACK functions.
https://towardsdatascience.com/optimizing-complex-simulations-use-scipy-interpolation-dc782c27dcd2
https://docs.scipy.org/doc/scipy/reference/tutorial/interpolate.html

👆🏻Not only CoPilot: Anomaly Detection in Software Development with ControlFlag by IntelLabs
Intel provided its response to OpenAI's AI CoPilot. Meet ControlFlag, a self-checking pattern detection system that learns typical patterns in the control structures of high-level programming languages like C / C ++ by pulling them from GitHub repositories, etc. These patterns are then used to detect anomalies in custom code. ControlFlag can be used to detect typos, missed NULL checks, and more.
Having first introduced the product at the end of 2020, in 2021 Intel opened up the ControlFlag source code based on the unsupervised learning method. After studying more than a billion lines of code, the system finds errors with high accuracy and is able to adapt to the style of individual developers in order to distinguish anomaly from the peculiarities of coding.
https://github.com/IntelLabs/control-flag

🌏⛈🍁TOP-15 the most interesting DS-conferences all over the world in November 2021
1. 01-02 Nov – 15th International Conference on Big Data Analytics and Big Data Science https://waset.org/big-data-analytics-and-big-data-science-conference-in-november-2021-in-san-francisco
2. 2 Nov - OSA Con, Open Source Analytics Conference, a free virtual event https://altinity.com/osa-con-2021/
3. 2-3 Nov - Chief Data & Analytics Officer, Europe – annual meeting https://cdao-eu.coriniumintelligence.com/
4. 3-4 Nov – 3rd International Conference on Big Data Analytics and Data Science https://crgconferences.com/datascience/
5. 3-4 Nov - Ai4 2021 Enterprise Summit, Exploring AI Across Industry https://ai4.io/enterprise-ai/
6. 4-6 Nov - AAAI 2021 Fall Symposium on Science Guided Machine Learning https://sites.google.com/vt.edu/sgai-aaai-21
7. 8-11 Nov - NVIDIA GTC, the Conference for AI Innovators, Technologists, and Creators https://www.nvidia.com/gtc/
8. 8-19 Nov - PRODUCT LEADERSHIP FESTIVAL 2021 - Product, Design & Data https://www.productleadership.com/events/product-leadership-festival
9. 9 Nov - RE.WORK Women in AI https://www.re-work.co/events/women-in-ai-virtual-2021
10. 11-12 Nov – DACH AI, Data Analytics and Insights Summit https://berryprofessionals.com/ai-data-analytics-and-insights-summit-dach/
11. 15-18 Nov - Toronto Machine Learning Summit (TMLS) 2021 https://www.torontomachinelearning.com/
12. 15-17 Nov - Marketing Analytics and Data Science https://informaconnect.com/marketing-analytics-data-science
13. 16-18 Nov – Open Data Science Conference https://odsc.com/
14. 18 Nov - SAS Global Learning Conference https://www.sas.com/content/sascom/sas/events/global-learning-conference.html
15. 21-25 Nov – Data Science Conference Europe 2021 https://datasciconference.com/

🙌🏻Simple combo for data analyst: 3 frameworks joining Python + spreadsheets
In practice, any data analyst works with datasets not only in Jupyter Notebook or Google Colab. Sometimes you have to open spreadsheet files Excel and Google Spreadsheets. Therefore, there is a need to combine Python scripts with built-in spreadsheet tools. The following frameworks come in handy for this:
• XLWings is a Python package that is actually preinstalled on Anaconda and is most often used to automate Excel processes. It is similar to Openpyxl, but more reliable and user-friendly. For example, you can write your own UDF in Python to parse web pages, machine learning, or solve NLP problems on data in a spreadsheet. https://www.xlwings.org/tutorials/
• Mito is a spreadsheet interface for Python, a spreadsheet within Jupyter that generates code. Mito supports basic Python functions like: merge, join, pivot, filtering, sorting, visualization, adding columns, using spreadsheet formulas, etc. https://docs.trymito.io/
• Openpyxl is a set of Python packages for reading from and writing to Excel. For example, you can connect to a local Excel file and access a specific cell or group of cells by fetching data into a DataFrame. And after processing, you can send the data back to the Excel file. In practice, this package is most often used in the financial sector, since processing large datasets in Excel is too slow. https://foss.heptapod.net/openpyxl/openpyxl