Obsetois in the Customer Success Management Industry

Obseto

obseto

⚡️ The new CSS property introduce for HTML element the capability to auto-sizing. aspect-ratio all { : / ; } { : / ; } { : / ; } { : / ; } { : (width) / (height);
} .square aspect-ratio 1 1 .rectangle aspect-ratio 3 1 .video aspect-ratio 16 9 .ultrawide aspect-ratio 21 9 .intrinsicsize aspect-ratio attr attr 🗣 Without the property , only some elements have a built-in auto-sizing system. aspect-ratio 📝 For instance, the tag when has at least the width value explicitly configured will implicitly calculate the height value and vice-versa. <img /> 🤩 Now, using aspect-ratio, even a can support the auto-sizing mechanism. <div> 📣 The new CSS property is useful to create responsive interfaces. aspect-ratio 👍 Also, help the developers to apply the best practices while working with images on the web since it allows manipulates with high precision the size of a given image using its original aspect ratio, which also will, in parallel, improve the performance metrics on . aspect-ratio since will be easy to identify images with a wrong resize rule Lighthouse ⚡️ is already supported on Chrome 88. Safari is reportedly working to support it soon. Firefox and Edge are starting to consider the support. aspect-ratio Also published at https://dev.to/obetomuniz/aspect-ratio-property-on-css-7lh

Understanding How CSS3 Aspect-Ratio Property Works

Procesando Datos Para Deep Learning: Datasets, visualizaciones y DataLoaders en PyTorch

La paginación es una técnica ampliamente utilizada en el diseño web que divide el contenido en varias páginas, presentando grandes conjuntos de datos de una manera mucho más fácil de digerir para los internautas. Hay muchos métodos de paginación empleados por diferentes desarrolladores web, como la paginación numerada, el desplazamiento infinito, etc. Aunque generalmente se cree que la paginación mejora la experiencia del usuario, la mala noticia es que dificulta el web scraping. Si está tratando de scrape datos de un sitio web y enfrenta un dilema sobre cómo abordar la paginación para el web scraping, lo tenemos cubierto. , una herramienta automática de web scraping, admite el manejo de sitios web de varias estructuras de paginación. Ahora vamos a ilustrar los diversos enfoques sobre cómo lidiar con diferentes tipos de paginación con Octoparse, que incluye: Octoparse Paginación con "next” botón Número de página sin botón "Next" Desplazamiento infinito "Load More" Botón 1. Paginación con next botón Hacer clic en el botón ”Siguiente" para paginar es quizás uno de los métodos más utilizados para la paginación, lo que facilita a los visitantes navegar por las páginas del sitio web. Es muy sencillo manejar este tipo de paginación para el web scraping en Octoparse. No importa si se trata de un botón siguiente que se muestra en la forma de la palabra - "Next" o simplemente una flecha hacia la derecha - ">", solo necesita crear un "bucle de paginación” para continuar haciendo clic en la página del botón después de scrape el objeto actual. (Mira un ejemplo ) aquí 2. Número de página sin botón "Siguiente" El enfoque para este tipo particular de paginación es muy similar al del botón siguiente. Desea crear un ciclo de paginación para seguir haciendo clic en el siguiente número de página en la línea. Sin embargo, dado que no hará clic en un elemento estático, localizar el siguiente número de página con precisión es fundamental. Octoparse usa XPath (Lenguaje de XML Path, que usa la sintaxis "path like" para identificar y navegar por los nodos en un documento XML) para localizar cualquier elemento. Entonces, el punto clave aquí es modificar la XPath del "buclo de paginación” para asegurarse de que siempre localizará el siguiente número de página tan pronto como la página actual se haya eliminado por completo (consulte para saber cómo modificar la XPath para ubicar con precisión la siguiente página número) este tutorial 3. Desplazamiento infinito Infinite-scrolling, also know as "endless scrolling" is a technique used most often by websites with JavaScript or AJAX to load additional content dynamically as users scroll down to the bottom of the webpage. Instead of using "previous/next" pagination buttons, many websites are turning to infinite scrolling, saving people from having to click through the many pages. Infinitive scrolling is typically used by websites with a large amount of data to display such as social media platforms like Facebook and Twitter. El desplazamiento infinito, también conocido como "endless scrolling", es una técnica utilizada con mayor frecuencia por los sitios web con JavaScript o AJAX para cargar contenido adicional de forma dinámica a medida que los usuarios se desplazan hacia la parte inferior de la página web. En lugar de utilizar los botones de paginación "anterior/siguiente", muchos sitios web están recurriendo al "desplazamiento infinito", evitando que las personas tengan que hacer clic en las muchas páginas. El desplazamiento infinitivo generalmente es utilizado por sitios web con una gran cantidad de datos para mostrar, como plataformas de redes sociales como Facebook y Twitter. Octoparse se ocupa del infinitive scrolling imitando el comportamiento del desplazamiento. Dependiendo de la cantidad de contenido que desee cargar, simplemente configure el tiempo de desplazamiento y la forma de desplazamiento adecuados, la página se desplazará automáticamente (consulte un ejemplo ) aquí 4. "Load More" Botón Cargar más botones de navegación es otra alternativa popular al desplazamiento infinito. En este caso, tendría un botón específico, como "Cargar más", para activar la carga de contenido con AJAX cuando llegue al final de la página. Octoparse trata con el botón "Cargar más" con un ciclo de paginación, que es lo mismo que tratamos con el botón "Siguiente", haciendo clic en un solo botón repetidamente. Sin embargo, la diferencia es que con el botón "Cargar más", debemos ejecutar el ciclo de paginación hasta que desaparezca el botón de carga antes de continuar con el siguiente paso. Después de cargar todo el contenido deseado, el proceso de scraping es tan fácil como scrape una sola página (verifique más detalles ) aquí Conclusion Pagination reduces page complexity and improves the readability of web content, yet it needs to be tackled using various approaches, whichever that creates maximum efficiency. If we fail to deal with pagination properly, it will result in missing data and a waste of time. Making good use of a web scraping tool like , you can avoid the complexities of web scraping! Octoparse Previously published at https://www.octoparse.es/blog/abordar-la-paginacion-para-web-scraping

Web Scraping 101: Abordar La Paginación para Web Scraping

On this post, I’ll show how to work with multiple queues, scheduled tasks, and retry when something goes wrong. If you don’t know how to use celery, read this post first: https://fernandofreitasalves.com/executing-time-consuming-tasks-asynchronously-with-django-and-celery/ Retrying a task Let’s say your task depends on an external API or connects to another web service and for any reason, it’s raising a ConnectionError, for instance. It’s plausible to think that after a few seconds the API, web service, or anything you are using may be back on track and working again. In this cases, you may want to catch an exception and retry your task. from celery import shared_task @shared_task(bind=True, max_retries=3)  # you can determine the max_retries heredef access_awful_system(self, my_obj_id):    from core.models import Object    from requests import ConnectionError     o = Object.objects.get(pk=my_obj_id)     # If ConnectionError try again in 180 seconds    try:         o.access_awful_system()      except ConnectionError as exc:        self.retry(exc=exc, countdown=180)  # the task goes back to the queue The self.retry inside a function is what’s interesting here. That’s possible thanks to bind=True on the shared_task decorator. It turns our function into a method of Task class. And it forced us to use self as the first argument of the function too. access_awful_system Another nice way to retry a function is using exponential backoff: self.retry(exc=exc, countdown=2 ** self.request.retries) ETA — Scheduling a task for later Now, imagine that your application has to call an asynchronous task, but need to wait one hour until running it. In this case, we just need to call the task using the ETA(estimated time of arrival) property and it means your task will be executed any time after ETA. To be precise not exactly in ETA time because it will depend if there are workers available at that time. If you want to schedule tasks exactly as you do in crontab, you may want to take a look at ). CeleryBeat from django.utils import timezonefrom datetime import timedelta

now = timezone.now()  # later is one hour from nowlater = now + timedelta(hours=1)

access_awful_system.apply_async((object_id), eta=later) Using more queues When you execute celery, it creates a queue on your broker (in the last blog post it was RabbitMQ). If you have a few asynchronous tasks and you use just the celery default queue, all tasks will be going to the same queue. Suppose that we have another task called and one more called and imagine that we have one single queue and four workers. too_long_task quick_task In that scenario, imagine if the producer sends ten messages to the queue to be executed by and right after that, it produces ten more messages to What is going to happen? All your workers may be occupied executing that went first on the queue and you don’t have workers on too_long_task quick_task. too_long_task quick_task. The solution for this is each task using named queues. routing # CELERY ROUTESCELERY_ROUTES = {    'core.tasks.too_long_task': {'queue': 'too_long_queue'},    'core.tasks.quick_task': {'queue': 'quick_queue'},} Now we can split the workers, determining which queue they will be consuming. # For too long queuecelery --app=proj_name worker -Q too_long_queue -c 2

# For quick queuecelery --app=proj_name worker -Q quick_queue -c 2 I’m using 2 workers for each queue, but it depends on your system. As, in the last post, you may want to run it on Supervisord There is a lot of interesting things to do with your workers here. Calling Sequential Tasks Another common issue is having to call two asynchronous tasks one after the other. It can happen in a lot of scenarios, e.g. if the second tasks use the first task as a parameter. You can use chain to do that from celery import chainfrom tasks import first_task, second_task chain(first_task.s(meu_objeto_id) | second_task.s()) The chain is a task too, so you can use parameters on apply_async, for instance, using an ETA: chain(salvar_dados.s(meu_objeto_id) | trabalhar_dados.s()).apply_async(eta=depois) Ignoring the results from ResultBackend If you just use tasks to execute something that doesn’t need the return from the task you can ignore the results and improve your performance. If you’re just saving something on your models, you’d like to use this in your settings.py: CELERY_IGNORE_RESULT = True Sources: _The default prefork pool scheduler is not friendly to long-running tasks, so if you have tasks that run for minutes…_docs.celeryproject.org Tasks — Celery 4.1.0 documentation _In Celery; If a task takes 10 minutes to complete, and there are 10 new tasks coming in every minute, the queue will…_docs.celeryproject.org Optimizing — Celery 4.1.0 documentation _While working on some projects that used Celery for a task queue I’ve gathered a number of best practices and decided…_denibertovic.com Deni Bertovic :: Celery — Best Practices _Try to keep a consistent module import pattern for celery tasks, or explicitly name them, as Celery does a lot of magic…_news.ycombinator.com Celery — Best Practices | Hacker News _More pool processes are usually better, but there’s a cut-off point where adding more pool processes affects…_docs.celeryproject.org Workers Guide — Celery 4.1.0 documentation _You just learned how to call a task using the tasks method in the guide, and this is often all you need, but sometimes…_docs.celeryproject.org Canvas: Designing Work-flows — Celery 4.1.0 documentation Super Bônus Celery Messaging at Scale at Instagram — Pycon 2013 Originally published at Fernando Alves .

Using celery with multiple queues, retries, and scheduled tasks

Un mercado es un mercado. Hoy fuimos a Brick Lane es un mercado a la afueras en el East London que es como la parte mas nueva y remodernizada de Londres. Es la parte de City of London propiamente dicha que no depende de Westmisnster. Es una ciudad independiente tiene sus propias leyes, su propia policía y sus propias reglas y si la Reina quiere entrar tiene que pedir permiso como al alcalde de la ciudad. (Obvio que siempre le dicen que si porque no quiere terminar en el fondo de Tamesis). Te das cuenta que estas en la City porque hay pilares negros en las calle con el escudo de la ciudad que no es el mismo que el que vemos siempre. Tiene dos leones a los costados como custodiando la entrada de la ciudad.Los fines de semana es un desierto porque como hay empresas y oficinas a lo un domingo es una ciudad fantasma. Retiro Hay peatonales internas que abren paso a vistas de lujo de los rascacielos mas importantes de la ciudad como el Gerkin. Una vez que pasas por esa zona llegas a la parte de Spitalfileds y Brick Lane. Tiene la fisonomia de un Palermo Soho o Palermo Viejo. Tipo la parte de . Con mercados de pulgas y venta de ropa vintage con puestos en la calle. Cordoba Hay un puesto de empanadas argentinas: carne, pollo jamón y queso y la famosa capresse. 3 por 5 libras. Recomendable si estas extrañando la comida de tu vieja. Esa parte hace unos cuantos años era un desastre y la levantaron y la rescataron toda. Esta graffiteada por donde la mires. Arte, moda, artistas callejeros y hasta un taxi viejo que funciona como puesto de venta de café. Todas las paredes intervenidas y en los puestos encontras ropa de marca, adaptadores de enchufes, anteojos, sombreros, productos de limpieza y hasta bolsas de arpillera gigantes que solían contener café y ahora las venden como objetos de decoración. Pasando el mercado llegas a Shoreditch la calle que lleva a la estación de tren. La cual es sin duda la estrella de la zona con graffitis, pintadas y hasta una canchita de fútbol 5 sintético por si pinta para un picadito después de las empanadas. Ya para emprender la vuelta, frente a la estación la bus stop y el puente del tren, te despide un alambrado que de a poco empieza a llenarse de candados porque como en el puente de las artes de Paris, la fuente en Montevideo o este alambrado de Shoreditch el amor hay que celebrarlo porque la promesa del amor eterno nos hace inmortales.

Un mercado es un mercado.

Know how each Cross-Site Scripting Attack behaves is crucial to start to think about how vulnerabilities in our web apps allow malicious codes to be executed using the browser to take sensible data from users. That's what this article is about. 🔓 Reflected XSS 📌 This attack XSS use URL parameters or data submitted via POST in forms to inject malicious code on that server request that persists some data for later execution in the browser. Third-party Browser extensions could even be an access point to inject such a malicious code. 🔓 Stored XSS 📌 This attack XSS happens when malicious code is persisted by the attacker directly in the server-side of the web app and is executed by the user (victim) when she accesses the infected application. 🔓 DOM XSS 📌 This attack XSS happens when the application manipulates the DOM incorrectly, opening breaches to malicious scripts sent by URL parameters to inject malicious code. 🔓 The question is... How to defend against attacks XSS? 📌 There's no formula - A system security is always dependent on that system context, keep this in mind, but there are practices against well-known XSS attacks to stay updated about XSS attacks. 👉 Start reading about Content Security Policy , Mozilla Observatory , OWASP recommendations , and signing up my newsletter . As a web security lover, I always talk about it. Also published on Dev.to

Types of Cross-Site Scripting(XSS) Attacks

. Content inspired after my first payment using Web Monetization API 🧑‍🔬 The How Sign up to and verify yourself wallet.uphold.com/signup Find the Interledger Payment Pointer in the Transact panel And pick a currency target. It could be USD, BTC, etc The Web Monetization API needs a to address micropayments for you. Payment Pointer 🏗 The Where You could use your previous created Uphold's Payment Pointer on your website using this declaration: < = = /> meta name "monetization" content "$ilp.your.payment/pointer" Also, dozens of services offer support: Twitch DEV.to Hashnode Cinnamon WordPress Even , when connected in a creator account on . YouTube Coil 💰 The Web Monetization API The that uses a neutral payment protocol called for transferring money for anyone by anyone. Web Monetization API is a W3C Standard Interledger (ILP) The proposal help web creators avoid systems that slow down the web and creates annoying UX 📚 More about Web Monetization Standards Get Monetized - A Coil's Overview about Web Monetization API Video in 🇧🇷 about Web Monetization API on my YouTube Channel 💌 Also, don't miss content like this signing my newsletter Also published on Dev.to

An Introduction To Web Monetization API

The ability to gather information from images has profound business potential. And, well, it can also just be fun. In this article, I’ll outline how we used to rapidly build an image object detection feature for a social media startup. Amazon Rekognition What Is Image Object Detection? Simply put, image object detection is the process of detecting and extracting information about entities in a given image. This involves detecting objects, activities, places, animals, products, etc. Image object detection has a wide array of use cases across a variety of industries. Major sectors such as banks, insurance, social media, dating apps, news agencies, and FinTech use object detection in some form or another. Our Use Case Recently, we were tasked with building an image object detection feature for a social media startup. The use case was simple — users should be able to select some of their favorite photos and submit them to be featured on one of the startup’s social media pages. The social media marketing team needed a way to search through the image submissions for certain themes — such as photos of the ocean, popular landmarks, animals, music concerts, etc. Image Analysis Using Deep Learning Analyzing images and classifying them based on scenery and objects within the image is no simple task. Human sight is nothing short of remarkable, and building an application that’s able to replicate the brain’s ability to detect objects is immensely complex. There is an entire computer vision industry devoted to doing just that. Performing object detection from scratch is typically a multi-step process that involves: Collecting images and labeling the objects within Training the ML models Using the trained models to perform the analysis Performance tuning And, repeat… Our aim for this feature, like all others on the project, was to build it quickly and test its efficacy in a production environment as soon as possible. Furthermore, we didn’t want to devote development resources to building a solution from the ground up when we could leverage existing cloud services. Cue Serverless — the startup’s entire backend is fully Serverless and event-driven. With this architecture, we’re able to have teams of developers that only need to focus on features that the social media app from others. Serverless also enables us to build highly scalable services whilst also only paying for exactly what we use — an important consideration for a scaling startup. differentiate So to achieve this feature, we used Amazon Rekognition — a fully Serverless image and video analysis service. Using Rekognition, we were able to develop this complex and critical workflow in a matter of . Let’s dive into it. hours What Is Amazon Rekognition? Amazon Rekognition is an AWS Serverless offering that uses deep learning to perform image and video analysis. Being fully Serverless means that with Rekognition we don’t need to worry about the complexity of the underlying infrastructure; we pay only for what we use it provides us with pre-written software for image and video analysis tasks. Rekognition offers a range of features, including image label detection, face detection, celebrity detection, content moderation, and text detection. and The best part? Rekognition abstracts away the heavy lifting of building, training, and analyzing deep learning models. Image and video analysis is quick and simple, with minimal set-up necessary. We didn’t need to worry about building and training our own datasets and provisioning server capacity so that our service would scale. All we needed to worry about was integrating. Architecture The architecture is straightforward. Our mobile app uploads images from users’ phones into an S3 bucket. The upload to S3 then triggers a Lambda function which in turn calls the Rekognition API and stores the results in DynamoDB for querying. Serverless image object detection architecture diagram using AWS The Code Writing code is fun, right? Well, writing less code is even more fun. Rekognition exposes a set of APIs that you send image data to which perform the analysis and return the results. For our use case, we used the API. detect-labels A simplified version of our Serverless framework Infrastructure as Code file looks like this: //serverless.yamlfunctions:
  imageLabelDetection:
    handler: image-label-detection.handler
      events:
        - s3:
          bucket: my-image-bucket
          event: s3:ObjectCreated:*
          existing: true
      iamRoleStatements:
        - Effect: Allow
          Action: rekognition:DetectLabels
          Resource: "*"
        - Effect: Allow
          Action: s3:GetObject
          Resource: arn:aws:s3:::my-image-bucket Our Lambda code simply calls the Rekognition API and stores the results in DynamoDB, but you can use whatever makes sense for your use case. We obtain the S3 bucket name and the image’s object name from the S3 event and pass those into the function of the . detectLabels Rekognition SDK We also pass in two optional parameters (MaxLabels and MinConfidence) to specify the confidence level threshold and a maximum number of labels that we want returned. In the example below, we will only get up to 20 labels in the response, and all labels will have a confidence level of more than 80%. //image-label-detecion.jsconst AWS = require("aws-sdk");const rekognition = new AWS.Rekognition();exports.handler = async (event) => {
  const imageDetails = event.Records[0].s3;  const bucketName = imageDetails.bucket.name;
  const objectKey = imageDetails.object.key;  const rekognitionResp = await rekognition
    .detectLabels({
      Image: {
        S3Object: {
          Bucket: bucketName,
          Name: objectKey,
        },
      },
      MaxLabels: 20,
      MinConfidence: 80,
    })
    .promise();  // Send to data store, e.g. DynamoDB
  // ...
}; Who doesn’t love a picture of a dog? Below is a response for an image that we uploaded to our S3 bucket. As you can see, Rekognition correctly determines that it’s an image of a dog on an outdoor, gravel path (and tells us where in the image the dog is!). Rekognition response (left), uploaded image (right). Final Thoughts So, what are my thoughts after using Rekognition in production for a few months? Here is a list of key takeaways: Fully Serverless — Avoid the undifferentiated heavy lifting of managing underlying infrastructure complexity and use pre-built software and pre-trained models. Performance — Rekognition is quick, around 600ms in most cases. Easy to use — The API is simple and easy to integrate with. Continuous improvement — AWS is constantly maintaining and iterating on Rekognition meaning it will become increasingly better over time. Accuracy — Rekognition takes advantage of Amazon’s broad set of customers; resulting in highly accurate image label detection. Has a generous free tier, so you can trial before deciding. Cost — We pay only for what we use. Rekognition allows us to scale up and down based on business needs. Summary TLDR: Rekognition enabled us to rapidly build an image object detection feature that’s accurate, fast, and scalable.

Using Amazon Rekognition to Build an Image Object Detection Feature for a Social Media Startup

সোশ্যাল মিডিয়া স্টার্টআপের জন্য একটি ইমেজ অবজেক্ট ডিটেকশন ফিচার তৈরি করতে অ্যামাজন রেকগনিশন ব্যবহার করা

Mithilfe von Amazon Rekognition eine Funktion zur Bildobjekterkennung für ein Social-Media-Startup erstellen

Uso de Amazon Rekognition para crear una función de detección de objetos de imagen para una startup de redes sociales

Utilisation d'Amazon Rekognition pour créer une fonctionnalité de détection d'objets image pour une startup de médias sociaux

सोशल मीडिया स्टार्टअप के लिए इमेज ऑब्जेक्ट डिटेक्शन फीचर बनाने के लिए अमेज़न रेकोग्निशन का उपयोग करना

Amazon Rekognition を使用してソーシャルメディアスタートアップ向けの画像オブジェクト検出機能を構築する

Amazon Rekognition을 사용하여 소셜 미디어 스타트업을 위한 이미지 객체 감지 기능 구축

Usando o Amazon Rekognition para criar um recurso de detecção de objetos de imagem para uma startup de mídia social

Использование Amazon Rekognition для создания функции обнаружения объектов изображений для стартапа в социальных сетях

Bir Sosyal Medya Kuruluşu için Görüntü Nesnesi Algılama Özelliği Oluşturmak İçin Amazon Rekognition'ı Kullanma

Sử dụng Amazon Rekognition để xây dựng tính năng phát hiện đối tượng hình ảnh cho một công ty khởi nghiệp trên mạng xã hội

使用 Amazon Rekognition 为社交媒体初创公司构建图像对象检测功能

A chain is as strong as its weakest link - and your AI/ML infrastructure is only as fast as your slowest component. If you train machine learning models with GPUs, then your weak link may be your storage solution. The result is what I call the “Starving GPU Problem.”  The Starving GPU problem occurs when your network or your storage solution cannot serve training data to your training logic fast enough to fully utilize your GPUs. The symptoms are fairly obvious. If you are monitoring your GPUs, then you will notice that they never get close to being fully utilized. If you have instrumented your training code, then you will notice that total training time is dominated by IO. Unfortunately, there is bad news for those who are wrestling with this issue. Let’s look at some advances being made with GPUs to understand how this problem is only going to get worse in the coming years. GPUs Are Getting Faster GPUs are getting faster. Not only is raw performance getting better, but memory and bandwidth are also increasing. Let’s take a look at these three characteristics of Nvidia’s most recent GPUs the , the and the . A100 H100 H200 GPU PERFORMANCE MEMORY MEMORY BANDWIDTH A100 624 TFLOPS 40GB 1,555GB/s H100 1,979 TFLOPS 80GB 3.35TB/s H200 1,979 TFLOPS 141GB 4.8TB/s The table above uses the statistics that align with a PCIe (Peripheral Component Interconnect Express) socket solution for the A100 and the SXM (Server PCI Express Module) socket solution for the H100 and the H200. SXM statistics do not exist for the A100. With respect to performance, the Floating Point 16 Tensor Core statistic is used for the comparison. A few observations on the statistics above are worth calling out. First, the H100 and the H200 have the same performance (1,979 TFLOPS), which is 3.17 times greater than the A100. The H100 has twice as much memory as the A100 and the memory bandwidth increased by a similar amount - which makes sense otherwise, the GPU would starve itself. The H200 can handle a whopping 141GB of memory and its memory bandwidth also increased proportionally with respect to the other GPUs. Let’s look at each of these statistics in more detail and discuss what it means to machine learning. - A teraflop (TFLOP) is one trillion (10^12) floating-point operations per second. That is a 1 with 12 zeros after it (1,000,000,000,000). It is hard to equate TFLOPs to IO demand in gigabytes as the floating point operations that occur during model training involve simple tensor math as well as first derivates against the loss function (a.k.a. gradients). However, relative comparisons are possible. Looking at the statistics above, we see that the H100 and the H200, which both perform at 1,979 TFLOPS, are 3 times faster - potentially consuming data 3 times faster if everything else can keep up. Performance - Also known as Video RAM or Graphics RAM. The GPU memory is separate from the system's main memory (RAM) and is specifically designed to handle the intensive graphical processing tasks performed by the graphics card. GPU memory dictates batch size when training models. In the past batch size was decreased when moving training logic from a CPU to a GPU. However, as GPU memory catches up with CPU memory in terms of capacity, the batch size used for GPU training will increase. When performance and memory capacity increase at the same time, the result is larger requests where each gigabyte of training data is getting processed faster. GPU Memory - Think of GPU memory bandwidth as the "highway" that connects the memory and computation cores. It determines how much data can be transferred per unit of time. Just like a wider highway allows more cars to pass in a given amount of time, a higher memory bandwidth allows more data to be moved between memory and the GPU. As you can see, the designers of these GPUs increased the memory bandwidth for each new version proportional to memory; therefore, the internal data bus of the chip will not be the bottleneck. Memory Bandwidth A Look into the Future In August 2023, Nvidia its next-generation platform for accelerated computing and generative AI - The GH200 Grace Hopper Superchip Platform. The new platform uses the , which can be connected with additional Superchips by , allowing them to work together during model training and inference. announced Grace Hopper Superchip NVIDIA NVLink While all the specifications on the Grace Hopper Superchip represent an improvement over previous chips, the most important innovation for AI/ML engineers is its unified memory. Grace Hopper gives the GPU full access to the CPU’s memory. This is important because, in the past, engineers wishing to use GPUs for training had to first pull data into system memory and then from there, move the data to the GPU memory. Grace Hopper eliminates the need to use the CPU’s memory as a bounce buffer to get data to the GPU. The simple comparison of a few key GPU statistics as well as the capabilities of Grace Hopper, has got to be a little scary to anyone responsible for upgrading GPUs and making sure everything else can keep up. A storage solution will absolutely need to serve data at a faster rate to keep up with these GPU improvements. Let’s look at a common solution to the hungry GPU problem. A Common Solution There is a common and obvious solution to this problem that does not require organizations to replace or upgrade their existing storage solution. You can keep your existing storage solution intact so that you can take advantage of all the enterprise features your organization requires. This storage solution is most likely a Data Lake that holds all of your organization’s unstructured data - therefore, it may be quite large, and the total cost of ownership is a consideration. It also has a lot of features enabled for redundancy, reliability and security, all of which impact performance. What can be done, however, is to set up a storage solution that is in the same data center as your compute infrastructure - ideally, this would be in the same cluster as your compute. Make sure you have a high-speed network with the best storage devices available. From there, copy only the data needed for ML training. Amazon’s recently announced exemplifies this approach. It is a bucket type optimized for high throughput and low latency and is confined to a single Availability Zone (no replication). Amazon’s intention is for customers to use it to hold a copy of data that requires high-speed access. Consequently, it is purpose-built for model training. According to Amazon, it provides 10x the data access speed of S3 Standard at 8x the cost. Read more about our assessment of Amazon S3 Express One Zone . Amazon S3 Express One Zone here The MinIO Solution The common solution I outlined above required AWS to customize its S3 storage solution by offering specialty buckets at an increased cost. Additionally, some organizations (that are not MinIO customers) are buying specialized storage solutions that do the simple things I described above. Unfortunately, this adds complexity to an existing infrastructure since a new product is needed to solve a relatively simple problem. The irony to all this is that MinIO customers have always had this option. You can do exactly what I described above with a new installation of MinIO on a high-speed network with NVMe drives. MinIO is a software-defined storage solution - the same product runs on bare metal or the cluster of your choice using a variety of storage devices. If your corporate Data Lake uses MinIO on bare metal with HDDs and it is working fine for all of your non-ML data - then there is no reason to replace it. However, if the datasets used for ML require faster IO because you are using GPUs, then consider the approach I outlined in this post. Be sure to make a copy of your ML data for use in your high-speed instance of MinIO - a gold copy should always exist in a hardened installation of MinIO. This will allow you to turn off features like replication and encryption in your high-speed instance of MinIO, further increasing performance. Copying data is easy using MinIO’s feature. mirroring MinIO is capable of the performance needed to feed your hungry GPUs - a achieved 325 GiB/s on GETs and 165 GiB/s on PUTs with just 32 nodes of off-the-shelf NVMe SSDs. recent benchmark Download today and learn just how easy it is to build a data lakehouse. If you have any questions be sure to reach out to us on ! MinIO Slack Also appears . here

Hungry GPUs Need Fast Object Storage

ক্ষুধার্ত জিপিইউগুলির দ্রুত অবজেক্ট স্টোরেজ প্রয়োজন

Hungrige GPUs benötigen schnellen Objektspeicher

Las GPU hambrientas necesitan un almacenamiento de objetos rápido

Les GPU gourmands ont besoin d'un stockage d'objets rapide

भूखे GPU को तेज़ ऑब्जेक्ट स्टोरेज की आवश्यकता होती है

飢餓状態の GPU には高速オブジェクト ストレージが必要

배고픈 GPU에는 빠른 개체 스토리지가 필요합니다

GPUs famintas precisam de armazenamento rápido de objetos

Голодным графическим процессорам требуется быстрое объектное хранилище

Aç GPU'ların Hızlı Nesne Depolamaya İhtiyacı Var

GPU đói cần lưu trữ đối tượng nhanh

饥饿的 GPU 需要快速的对象存储

JavaScript Objects: From Fundamentals to Advanced Techniques

জাভাস্ক্রিপ্ট অবজেক্ট: ফান্ডামেন্টাল থেকে অ্যাডভান্সড টেকনিক

JavaScript-Objekte: Von den Grundlagen zu fortgeschrittenen Techniken

Objetos JavaScript: de los fundamentos a las técnicas avanzadas

Objets JavaScript : des fondamentaux aux techniques avancées

जावास्क्रिप्ट ऑब्जेक्ट: बुनियादी बातों से लेकर उन्नत तकनीकों तक

JavaScript オブジェクト: 基本から高度なテクニックまで

JavaScript 객체: 기초부터 고급 기술까지

Objetos JavaScript: dos fundamentos às técnicas avançadas

Объекты JavaScript: от основ к продвинутым методам

JavaScript Nesneleri: Temellerden İleri Tekniklere

Đối tượng JavaScript: Từ cơ bản đến kỹ thuật nâng cao

JavaScript 对象：从基础知识到高级技术

Computer vision remains an extremely compelling application of artificial intelligence. Whether it’s recognizing elements on a battlefield or predicting crop yields, computer vision is arguably one of the most commercially valuable (and societally important) realms of AI. However, a rate-limiter to the adoption of the best computer vision capabilities is oftentimes the complexities associated with constructing a dataset and designing a simple end-to-end system that will perform your computer vision task on a new image. In this blog post, we will take a step-by-step look at how to tackle these issues with best-in-class tools like CVAT and MinIO Bucket Notifications. By the end of this post, you will be able to train an object detection model on a custom dataset and use it to make predictions whenever a new image appears. The Premise Let’s say we want to be able to recognize types of aircraft present in satellite imagery. Let’s also assume we are starting from scratch: no pre-built datasets, no pre-trained models. Here are two sample aircraft that we want to detect and recognize in our satellite imagery: The steps outlined in this post can be generalized to just about any domain. Instead of detecting aircraft types, we could be classifying land use or performing regression to predict crop yields. Beyond traditional images, we could also be training and performing inference on other types of multi-dimensional data like LiDAR point clouds or 3D Seismic Images; it becomes just a question of how the training data looks (and potentially a different deep learning model instead of YOLO). If you have more questions about what this would look like for a specific use case, feel free to make an issue on the GitHub ! repo Step 1: Acquiring and Managing Training Samples For this project, due in large part to not owning an on-demand imaging satellite, I visited airfields on Google Earth and took multiple screenshots of areas that had some of these planes visible. Assembling this set of images took quite some time, so I stored them all in a bucket on my MinIO server titled “object-detection.” In a production setting, the benefits of storing your collected samples on MinIO become even more prescient. Active-active replication, the highest levels of encryption, and super fast GET/PUTs (to name a few) mean that your diligently-collected samples will be highly available, safe and secure. Step 2: Creating the Dataset In order to train an object detection model for your use case, a labeled (or ‘annotated’) dataset is needed. A great tool for this is CVAT by OpenCV. A cool feature is that CVAT provides a utility to connect your MinIO bucket as a “cloud storage” in order to feed your bucket’s images directly to the dataset annotation tool. To do this, make sure that your MinIO Server’s host is accessible to the CVAT server, especially if you’re running MinIO Server on-premise or locally on your laptop. Also, as a note, there are two ways to use CVAT: (1) using their provided web app at or (2) running it locally. In either case, once you have CVAT open, click on “Cloud Storages” in the menu bar. From there, you can fill out a form to attach your (S3-Compatible) MinIO bucket: app.cvat.ai Let’s now create our new labeling task under “Tasks”: You should be prompted with a form to fill out: When creating the task, it’s important to define the class labels correctly (I defined two Rectangle labels titled “SU30” and “TU95,” corresponding to the two planes I wanted to detect): Now the remaining step is to attach our previously added MinIO bucket as a data source. Under “Select Files,” click “Cloud Storage” and fill in the name you provided for that source earlier. I used the name “minio-cv-bucket” above. The uploading process will take a few minutes. Once it’s completed, you should be able to see your annotation job available under “Jobs.” Now, by clicking on the job, you can start annotating each of your images. Warning: this can be a disproportionately time-consuming process. Generally, in a production environment with large annotation needs, it may be best to offload this task to a dedicated internal team or a third-party data labeling company. Once you’re done annotating, export the dataset in the YOLO format. Step 3: Organizing the Training Data Your exported dataset will be in the form of a zip file. Once you unzip it, the YOLO-formatted annotation text files will be within an enclosed folder. Feel free to take a look at them. In the YOLO format, each image’s annotations are in a text file where each line contains two corners of a bounding box and the class. The class number corresponds to the order in which you defined the labels when creating the task. So, in this example, 0 would correspond to Su-30, and 1 would correspond to Tu-95. At this point, create a new working directory (or enter one that you have already created). Within this directory, create a subdirectory called 'dataset.' Within ‘dataset’, create directories such that your working directory looks like this: my_cv_project (WORKING DIRECTORY)
|---- dataset
	|----images
		|----train
		|----val
		|----test
	|----annotations

		|----train
		|----val
		|----test You will now have to populate the train, val, and test subdirectories for both images and their corresponding annotations (the text files). It’s up to you how you want to retrieve and split up your samples. A good practice is to break up your total amount of training samples into 80% training, 10% validation, and 10% test. Make sure to randomly shuffle your images before partitioning them. Personally, I used MinIO Client’s in the command line to quickly retrieve all the images from my ‘object-detection’ bucket. Alternatively, if you have all your sample images in one place on your local computer already, you can directly work with that. Once I had all my samples in one place, I used a Python script to shuffle, split, and move my images and annotations to the train, val, and test directories. . If you have any questions about how to use it, feel free to make an issue in the ! mc cp Here is the script provided for convenience repo Ultimately, make sure that for each image that you have placed in either images/train, images/val, or images/test, the matching annotation .txt file is also in the corresponding subdirectory within the annotations/ directory. For example: my_cv_project (WORKING DIRECTORY)
|---- dataset
	|----images
		|----train
			- 5.png
			- 3.png
			- 2.png
		|----val
			- 4.png
		|----test
			- 1.png
	|----annotations
		|----train
			- 5.txt
			- 3.txt
			- 2.txt
		|----val
			- 4.txt
		|----test
			- 1.txt Now, our data is in place. It’s time to take a look at our object detection model and start training. Step 4: The Object Detection Model The current gold standard (in terms of performance and ease of use) for object recognition is the YOLO (You Only Look Once) class of models. At the time of writing, YOLOv8 is the latest version and is maintained as open-source by Ultralytics. YOLOv8 provides a simple API that we can leverage to train the model on our newly created annotations (and eventually run inference as well). Let’s download YOLOv8: $ pip install ultralytics We can now use the YOLOv8 CLI tool or Python SDK to train, validate, and predict. Refer to the YOLOv8 docs for further information. Step 5: Training In your working directory, define a YAML file that specifies the locations of the dataset and the details about the classes. Notice how the paths are the same as the ones I created earlier in the working directory. I called my file ‘ .’ Also, note the two aircraft class labels have to be defined in the same order as they were in CVAT. objdetect.yaml train: ./dataset/images/train/ 
val:  ./dataset/images/val/
test: ./dataset/images/test/

# number of classes
nc: 2

# class names
names: ["SU-30","TU-95"] Start training the YOLOv8 model on our dataset with the following command (using the YOLO CLI tool). Refer to the YOLO docs to learn more about all the different options you can configure for training. Here, I am initiating training for 100 epochs and setting an image size of 640 pixels (all our training images will be scaled accordingly during training): $ yolo task=detect \
  mode=train \
  model=yolov8s.pt \
  data=objdetect.yaml \
  epochs=100 \
  imgsz=640 Training will take a while, especially if you’re working on a laptop (like I am), so now is a good time to take a break (or read ahead 😀)! At the end of the training loop, your trained model, along with other interesting graphs and charts, will be stored in an auto-generated directory called ‘runs.’ The terminal output (like below) will indicate the specific location of the results of the latest run. Every time you train a model, a similar directory will be generated within ‘runs/detect/’. Results saved to runs/detect/train Note: runs/detect/train/weights/ will contain the PT files with the exact trained weights. Remember this location for later. Step 5B: Model Validation and Test You can run validation with the following command: $ yolo task=detect \                                       
  mode=val \
  model=path/to/best.pt \
  data=objdetect.yaml The results will be automatically stored in a folder in your working directory with a path of the form ‘runs/detect/val.’ To perform inference on the test set, you can use the following command: $ yolo task=detect \                                                    
  mode=predict \
  model=path/to/best.pt \
  conf=0.5 \
  source=dataset/images/test The results will be stored in ‘runs/detect/predict.’ Here are some prediction results on the test set: Step 6: New Image Inference using MinIO Bucket Notifications Now that we have a trained model that can recognize some aircraft types present in a satellite image, ? how can we make use of it for new images in a simple way is a perfect tool for this. We can build a system that can automatically perform object detection inference upon a new image dropped in our bucket with the help of a webhook. MinIO Bucket Notifications At a high level, we have 3 steps. First, we need to define an endpoint that can serve as a webhook to perform object detection on a new image with our trained model. Second, we need to configure some environment variables for our MinIO Server deployment that instruct it to hit our webhook endpoint upon some event happening. Third, we need to configure what types of bucket events (i.e. PUT) we want to act on. Let's walk through it step-by-step. Here’s the code for a simple Flask-based server ( ) that runs inference on a new image added to the MinIO bucket: detection_server.py """
This is a simple Flask inference server implementation that serves as a webhook for the event of a new image being added to a MinIO bucket. Object detection using YOLO will be performed on that image and the resulting predictions will be returned.
"""
from flask import Flask, request, abort, make_response
from ultralytics import YOLO
import tempfile
from minio import Minio

# Make sure the following are populated with your MinIO details
# (Best practice is to use environment variables!)
MINIO_ENDPOINT = ''
MINIO_ACCESS_KEY = ''
MINIO_SECRET_KEY = ''

model = YOLO('/PATH/TO/best.pt')  # load a custom model (path to trained weights)

client = Minio(
    MINIO_ENDPOINT,
    access_key=MINIO_ACCESS_KEY,
    secret_key=MINIO_SECRET_KEY,
)

app = Flask(__name__)

@app.route('/', methods=['POST'])
async def inference_bucket_webhook():
    """
    This endpoint will be called when a new object is placed in your inference bucket
    """
    if request.method == 'POST':
        # Get the request event from the 'POST' call
        event = request.json
        bucket = event['Records'][0]['s3']['bucket']['name']
        obj_name = event['Records'][0]['s3']['object']['key']
        with tempfile.TemporaryDirectory() as temp_dir:
            temp_file_name = temp_dir+'/'+obj_name
            client.fget_object(bucket, obj_name, temp_file_name)
            # See https://docs.ultralytics.com/modes/predict/ for more information about YOLO inference options
            results = model.predict(source=temp_file_name, conf=0.5, stream=False)
            # A list of bounding boxes (if any) is returned.
            # Each bounding box is in the format [x1, y1, x2, y2, probability, class].
            result = {"results": results[0].boxes.data.tolist()}
            print(result)
            resp = make_response(result, 200)
            return resp
    else:
        abort(400)

if __name__ == '__main__':
    app.run() Let’s start the inference server: $ python detection_server.py
 * Serving Flask app 'detection_server'
 * Debug mode: off
 * Running on http://127.0.0.1:5000
Press CTRL+C to quit Make note of the hostname and port that the Flask application is running on. Next, let’s start working on configuring the webhooks on the MinIO side. First, set the following environment variables. Replace <YOURFUNCTIONNAME> with a function name of your choosing. For simplicity, I went with Also, make sure that the endpoint environment variable is set to the correct host and port for your inference server. In this case, http://localhost:5000 is where our Flask application is running. ‘inference.’ $ export MINIO_NOTIFY_WEBHOOK_ENABLE_<YOURFUNCTIONNAME>=on 
$ export MINIO_NOTIFY_WEBHOOK_ENDPOINT_<YOURFUNCTIONNAME>=http://localhost:5000 Now, restart the MinIO Server using the command or if you’re starting the server for the first time you can also just use the command. For more information about re/starting the MinIO Server, check out the MinIO docs. Note: ALIAS should be replaced with the alias for your MinIO server deployment. For more information about how to set an alias or view existing aliases, check out . mc admin service restart ALIAS minio server the docs Finally, let’s add the bucket and event we want to be notified about. In our case, we want to be notified about ` events (creation of new objects) in our bucket. I made a brand new, empty bucket for this purpose titled so I will substitute that for ‘BUCKET.’ put` “detect-inference,” $ mc event add ALIAS/BUCKET arn:minio:sqs::<YOURFUNCTIONNAME>:webhook --event put You can check that you have configured the correct event type for the bucket notifications by verifying whether " " is outputted when you run this command: s3:ObjectCreated:* $ mc event ls local/detect-inference arn:minio:sqs::<YOURFUNCTIONNAME>:webhook For a more detailed explanation of publishing bucket events to a webhook, check out the . We are now ready to try object detection on a brand new image! docs Trying out our Inference System Here’s the new image (titled ‘1.png’) I want to conduct inference on: I drop the new image in my ‘detect-inference’ bucket: Almost instantly, I’m able to see the following results on my Flask server: $ python detection_server.py
 * Serving Flask app 'detection_server'
 * Debug mode: off
 * Running on http://127.0.0.1:5000
Press CTRL+C to quit

image 1/1 /var/folders/xf/q7x0z8sn5nvckccp1g0m1vpm0000gn/T/tmpo6jx3w8u/1.png: 448x736 2 SU-30s, 101.0ms
Speed: 4.1ms preprocess, 101.0ms inference, 5.8ms postprocess per image at shape (1, 3, 448, 736)
{'results': [[1927.78369140625, 627.7123413085938, 1995.090576171875, 715.3443603515625, 0.8142037987709045, 0.0], [1735.740234375, 477.2108154296875, 1809.181640625, 555.767578125, 0.7766116261482239, 0.0]]}
127.0.0.1 - - [14/Sep/2023 15:39:21] "POST / HTTP/1.1" 200 - Note that each detected bounding box in the results list is in the YOLO format [x1, y1, x2, y2, probability, class]. Here are the bounding boxes and predicted classes superimposed on the original image: Note: For production environments and/or large machine learning models, it’s a good idea to use an established model serving framework like PyTorch Serve or Triton Server to make inference more robust and reliable. If you’re interested in that, check out the previous post on . Optimizing AI Model Serving with MinIO and PyTorch Serve Concluding Thoughts We did it! We walked through how MinIO and CVAT came together to keep our collected image samples safe and available, as well as how to create our custom object detection dataset. Then, we trained our own custom YOLO model for our custom task. Lastly, with just over 50 lines of code, we put together an inference server using MinIO Bucket Notifications that could run a new image past our custom trained object detection model. Furthermore, for most mission critical applications of computer vision, it is best to conduct inference on the edge. Otherwise, said applications are vulnerable to the latency associated with uploading new data to the public cloud and waiting for an inference server in the cloud to get back with an answer– not to mention the risks of a faulty network connection. For this reason, a computer vision pipeline centered around MinIO as the data layer makes much more sense. Imagine a drone flying over an airfield, being able to capture, store, and use our trained model on new imagery with completely-on-board hardware and software. With a local deployment of MinIO server, the Bucket Notification-based inference system we built at the end of the post works perfectly for this scenario and countless others like it. If you have any questions join our or drop us a note at . We are here to help you. Slack Channel hello@min.io Also published . here

How to Train an Object Detection Model Using a Custom Dataset With MinIO and YOLO

MinIO এবং YOLO এর সাথে একটি কাস্টম ডেটাসেট ব্যবহার করে কীভাবে একটি অবজেক্ট সনাক্তকরণ মডেলকে প্রশিক্ষণ দেওয়া যায়

So trainieren Sie ein Objekterkennungsmodell mithilfe eines benutzerdefinierten Datensatzes mit MinIO und YOLO

Cómo entrenar un modelo de detección de objetos utilizando un conjunto de datos personalizado con MinIO y YOLO

Comment former un modèle de détection d'objets à l'aide d'un ensemble de données personnalisé avec MinIO et YOLO

मिनिओ और योलो के साथ कस्टम डेटासेट का उपयोग करके ऑब्जेक्ट डिटेक्शन मॉडल को कैसे प्रशिक्षित करें

MinIO と YOLO でカスタム データセットを使用して物体検出モデルをトレーニングする方法

MinIO 및 YOLO와 함께 사용자 정의 데이터 세트를 사용하여 객체 감지 모델을 훈련하는 방법

Como treinar um modelo de detecção de objetos usando um conjunto de dados personalizado com MinIO e YOLO

Как обучить модель обнаружения объектов с использованием пользовательского набора данных с помощью MinIO и YOLO

MinIO ve YOLO ile Özel Bir Veri Kümesi Kullanılarak Nesne Algılama Modeli Nasıl Eğitilir

Cách đào tạo mô hình phát hiện đối tượng bằng cách sử dụng bộ dữ liệu tùy chỉnh với MinIO và YOLO

如何使用 MinIO 和 YOLO 的自定义数据集训练对象检测模型

When purchasing storage, the emphasis is usually on media, but it may be even more important to consider access methods too. You will need to take storage protocols into account when designing and procuring infrastructure, especially when you leave legacy storage behind in order to migrate to cloud-native object storage. However, object storage relies on the S3 API for communications, while legacy workloads rely on POSIX, the Portable Operating System Interface that provides a set of standards developed in the 1980s to allow applications to be portable between Unix OSs. Chances are that most enterprises have had applications in service for decades that were developed to run on POSIX. Chances are also that engineers are already aware of POSIX’s poor performance. That being said, when you have legacy systems that can only ingest data in a certain format or from a certain source, your options might be limited and you may have no choice but to implement an outdated protocol or rewrite your code. For example, if you can only ingest from a local disk with a filesystem and not with RESTful APIs accessed over network, then you must first make that data available on disk before your application can use it. However, using an object store as a filesystem has a number of serious negative implications when it comes to performance, compatibility, data integrity and security. Let’s demonstrate  this with some real world testing using a small utility called . This utility allows you to mount an S3 bucket as a local filesystem. It stands for S3 (Simple Storage Service) File System - FUSE (Filesystem in Userspace). It's an open-source project that leverages the FUSE (Filesystem in Userspace) interface to present a filesystem-like interface to S3. s3fs-fuse Once an S3 bucket is mounted using , you can interact with the bucket as if it were a local filesystem. This means you can use regular file operations (like read, write, move, etc.) on files in your bucket. This sounds amazingly convenient and we can argue it simplifies application development. But inherently object storage and file systems have fundamental differences that will affect the s3 bucket mounted as a filesystem. s3fs-fuse Let’s take a moment to step back from the utility to discuss the real reasons why treating object storage as a filesystem is far from optimal. The problem is much bigger than and includes other utilities such as Rust based , a file client that translates local file system API calls to S3 object API calls. The first reason is that all of these utilities rely on POSIX for filesystem operations. POSIX is inefficient and it was never intended for working with very large files over-the-network. s3fs-fuse s3fs-fuse Mountpoint for Amazon S3 The speed of POSIX based systems decreases as the demand, especially concurrent demand, on them increases. When large organizations need to store and access oceans of data for deep learning, AI, and other data intensive use cases, POSIX does not have the ability or scalability to meet these demands. While all-Flash arrays have kept POSIX in the game, scalability and RESTful APIs (the hallmarks of the cloud) are like kryptonite. Because of this, running POSIX on top of an object store is suboptimal. Let’s take a look at some of the reasons why: POSIX FS interface is inherently IOPS centric. They are chatty, expensive and hard to scale. RESTful S3 API addresses this by transforming IOPS into a throughput problem. Throughput is easier and cheaper to scale. This is why object storage is high-performance at a massive scale. Layering POSIX over S3 will not scale because POSIX is too chatty to be performed over an HTTP RESTful interface. Performance: Because object operations are atomic and immutable, there is no way to guarantee consistency correctness. This means you can lose the uncommitted data in case of a crash or run into corruption issues in case of shared mounts. Semantics: : Writes or any mutations to a file won't appear in the namespace until it is committed. This means concurrent access across shared mounts will not see the modifications. It is not useful for shared access. Data Integrity POSIX permissions and ACLs are primitive and incompatible with the S3 API’s way of handling identity and access management policies. It is not possible to safely implement POSIX access management on top S3 APIs. Access Control: POSIX also lacks most of the functionality that developers love about S3, such as  object level encryption, versioning, immutability – these simply have no equivalent in the POSIX world and nothing is able to translate them. POSIX Pain Points These examples illustrate the issue and its implications. To get started, we will use CSV file which is approximately 10GB and has 112 rows. this Note: We will assume the is already installed and you have mounted one of the buckets from the object storage into your filesystem. If not, follow the instructions . s3fs-fuse here In these examples, we will assume the bucket name is test-bucket and the file name is taxi-data.csv is in /home/user/ directory and is mounted at /home/user/test-bucket/ s3fs-fuse bucket Copy Operation We’ll try something simple first and try to copy the CSV file to our test-bucket using mc commands and record the time taken time mc cp /home/user/taxi-data.csv minio/test-bucket/taxi-data.csv This shouldn't take a lot of time and the file should be copied to our bucket. Now let’s try to do the same with s3fs-fuse time cp /home/user/taxi-data.csv /home/user/test-bucket/taxi-data.csv Time it took during the testing real	1m36.056s
user	0m14.507s
sys	0m31.891s In my case I was only able to copy the file partially to the bucket and the operation failed with the following error cp: error writing '/home/user/test-bucket/taxi-data.csv': Input/output error
cp: failed to close '/home/user/test-bucket/taxi-data.csv': Input/output error After multiple tries it succeeded real	5m3.661s
user	0m0.053s
sys	2m35.234s As you can see, because of the amount of API calls the utility needs to make and the general overhead of the operations, the utility becomes unstable and most of the operations do not even finish. Pandas Example We’ve shown you a simple example, which may or may not have been convincing, because let's face it, you might think is quite rudimentary. cp time cp So for the folks who need more empirical evidence let's write a Python snippet to test this. We’ll do a simple Pandas example with both and the package, and see the performance impact s3fs-fuse python s3fs import timeit
import os
import fsspec
import s3fs
import pandas as pd

# Write a dummy CSV file to test-bucket
df = pd.DataFrame({"column1": ["new_value1"], "column2": ["new_value2"]})
df.to_csv("s3://test-bucket/data/test-data.csv", index=False)


def process_s3():
    # add fsspec for pandas to use `s3://` path style and access S3 buckets directly
    fsspec.config.conf = {
      "s3":
      {
        "key": os.getenv("AWS_ACCESS_KEY_ID", "minioadmin"),
        "secret": os.getenv("AWS_SECRET_ACCESS_KEY", "minioadmin"),
        "client_kwargs": {
          "endpoint_url": os.getenv("S3_ENDPOINT", "https://play.min.io")
        }
      }
    }
    s3 = s3fs.S3FileSystem()
    for i in range(100):
        # Read the existing data
        print(i)
        df = pd.read_csv('s3://test-bucket/data/test-data.csv')
        # Append a new row
        new_df = pd.concat([df, pd.DataFrame([{"column1": f"value{i}", "column2": f"value{i}"}])], ignore_index=True)
        # Write the data back to the file
        new_df.to_csv('s3://test-bucket/data/test-data.csv', index=False)


execution_time = timeit.timeit(process_s3, number=1)
print(f"Execution time: {execution_time:.2f} seconds") Time taken during the testing Execution time: 8.54 seconds Now let's try the same for s3fs-fuse import timeit
import pandas as pd

# Write a dummy CSV file to test-bucket
df = pd.DataFrame({"column1": ["new_value1"], "column2": ["new_value2"]})
df.to_csv("s3://test-bucket/data/test-data.csv", index=False)


def process_s3fs():
    for i in range(100):
        # Read the existing data
        print(i)
        df = pd.read_csv('/home/user/test-bucket/data/test-data.csv')
        # Append a new row
        new_df = pd.concat([df, pd.DataFrame([{"column1": f"value{i}", "column2": f"value{i}"}])], ignore_index=True)
        # Write the data back to the file
        new_df.to_csv('/home/user/test-bucket/data/test-data.csv', index=False)


execution_time = timeit.timeit(process_s3fs, number=1)
print(f"Execution time: {execution_time:.2f} seconds") Time taken during the testing Execution time: 9.59 seconds These examples demonstrate constant reads and writes to S3 files. Imagine this performed concurrently by multiple clients – the latency grows dramatically. Remove the Overhead! As you can see, the difference between using POSIX translation to treat objects as files and using the direct API to work with objects is night and day. There is simply no comparison when it comes to security, performance, data integrity and compatibility. MinIO has to integrate with almost any popular programming language, and it can run on almost any platform such as Kubernetes, bare metal Linux, Docker containers – and much more. SDKs MinIO with encryption at rest and in-transit, combined with PBAC to regulate access and to protect data integrity. You will achieve the best performance possible, regardless of where you run MinIO, because it takes advantage of underlying hardware (see ) to deliver the greatest possible performance. We’ve MinIO at 325 GiB/s (349 GB/s) on GETs and 165 GiB/s (177 GB/s) on PUTs with just 32 nodes of off-the-shelf NVMe SSDs. secures objects erasure coding Selecting the Best Hardware for Your MinIO Deployment benchmarked There is simply no need for a filesystem utility in the middle of MinIO and your application! Any advantage legacy apps might receive will be offset by the pain of POSIX. If you have any questions about using POSIX translation for your application, be sure to reach out to us on ! Slack Also published . here

Why You Shouldn't Put a Filesystem on Top of an Object Store

কেন আপনি একটি অবজেক্ট স্টোরের উপরে একটি ফাইল সিস্টেম রাখা উচিত নয়

Warum Sie ein Dateisystem nicht über einen Objektspeicher legen sollten

Por qué no deberías poner un sistema de archivos encima de un almacén de objetos

Pourquoi vous ne devriez pas placer un système de fichiers au-dessus d'un magasin d'objets

आपको किसी ऑब्जेक्ट स्टोर के शीर्ष पर फ़ाइल सिस्टम क्यों नहीं रखना चाहिए?

ファイルシステムをオブジェクトストアの上に置くべきではない理由

객체 저장소 위에 파일 시스템을 배치하면 안되는 이유

Por que você não deve colocar um sistema de arquivos em cima de um armazenamento de objetos

Почему не следует размещать файловую систему поверх хранилища объектов

Neden Nesne Deposunun Üstüne Dosya Sistemi Koymamalısınız?

Tại sao bạn không nên đặt hệ thống tập tin lên trên kho lưu trữ đối tượng

为什么不应该将文件系统放在对象存储之上

Exciting news in the world of AI and image editing: Drag Your GAN, a groundbreaking research, was just ! introduced by Pan et al. This new approach allows you to alter images by simply dragging points from A to B, revolutionizing the way we interact with image editing. This isn’t just editing, but actually the creation of completely new images, allowing you to change object positions, subject poses, and more. Drag Your GAN prioritizes precise object dragging over image generation or text manipulation The AI realistically adapts the entire image, modifying the object's position, pose, shape, expressions, and other frame elements. 🐶🌄 Edit expressions of dogs, make them sit, adjust human poses, or even alter landscapes seamlessly. Drag Your GAN offers an innovative and interactive way to experiment with image editing. How does it work? Drag Your Gan leverages StyleGAN2, a state-of-the-art architecture by NVIDIA. By operating in the feature space (latent code), the AI learns how to edit images properly through a series of steps and loss calculations. GAN Even though the results are fantastic, as you will see below, it's essential to note that Drag Your Gan has some limitations, including only being able to edit generated images for now. Images are part of the distribution. Other limitations are that the selection of points is based on pixel colors and contrast, so you cannot really drag anything. If you take a part of a red car and move it staying on the red car, it might not understand that you move it at all. Can't wait to try it out? The authors mention that the code should be available in June. Tune in to the video to learn more about this new image manipulation style with DragYourGan! Learn More by Watching the Video and Skip to Any Portion You’d Like Via the Transcript https://youtu.be/r1mh-IqBEjg?embedable=true&transcript=true

Introducing Drag Your GAN: Drag Objects to Create New Images

আপনার GAN টেনে আনুন: নতুন ছবি তৈরি করতে অবজেক্ট টেনে আনুন

Einführung in Drag Your GAN: Ziehen Sie Objekte, um neue Bilder zu erstellen

Presentamos Drag Your GAN: arrastre objetos para crear nuevas imágenes

Présentation de Drag Your GAN : Faites glisser des objets pour créer de nouvelles images

पेश है ड्रैग योर गण: नई इमेज बनाने के लिए ऑब्जेक्ट को ड्रैग करें

Drag Your GAN の紹介: オブジェクトをドラッグして新しい画像を作成

GAN 드래그 소개: 개체를 드래그하여 새 이미지 만들기

Apresentando Drag Your GAN: Arraste objetos para criar novas imagens

GAN'ınızı Sürüklemeyle Tanışın: Yeni Görüntüler Oluşturmak için Nesneleri Sürükleyin

Giới thiệu Kéo GAN của bạn: Kéo đối tượng để tạo hình ảnh mới

介绍拖动你的 GAN：拖动对象创建新图像

Redux is a very popular solution for state management in React applications. I also work a lot with this library and in this short article, I want to share a way how we can use object notation to check our action types. In most cases, developers use 2 common ways to iterate through the action types. The first approach is to use construction. It can be useful for small reducers, where we have just one or two conditions. Here is an example of such a case: if else const SAVE_USER_NAME = 'SAVE_USER_NAME';

export const reducer = (state, { type, payload }) => {
    if (type === SAVE_USER_NAME) {
        return {
            ...state,
            name: payload,
        };
    }
    
    return state;
}; We have just one action type . And in our reducer we use construction to check the current action type. When it’s equal to true - we return the new state, when not - we just return the initial state. This is a good approach, but it will not be so nice when we have a couple of different action types. In this situation, another very popular solution which is used everywhere is construction. It allows us to iterate through a huge number of action types without . Example of this solution: SAVE_USER_NAME if switch if else const SAVE_USER_NAME = 'SAVE_USER_NAME';
const SAVE_USER_EMAIL = 'SAVE_USER_EMAIL';
const SAVE_USER_ADDRESS = 'SAVE_USER_ADDRESS';

export const reducer = (state, { type, payload }) => {
    switch (type) {
        case SAVE_USER_NAME:
            return { ...state, name: payload };
        case SAVE_USER_EMAIL:
            return { ...state, email: payload };
        case SAVE_USER_ADDRESS:
            return { ...state, address: payload };
        default:
            return state;
    }
}; It looks much better than if we use a lot of . But in my experience sometimes I had to deal with reducers where we have 40 or even 60 ‘cases’.  And, as we have used SonarQube in our CI/CD pipeline, it started to send many alerts because there were too many ‘cases’ in block. So how we can fix this? else if switch The first thing that we can do is to split our big reducer into several smaller ones. But what if we don’t want to do this or we don’t have enough time? Do we have another way how to refactor this reducer and remove ? switch Yeah, we have. And here we can use objects. I’m a big fan of objects, and hash maps, and I just refactored the previous solution: const SAVE_USER_NAME = 'SAVE_USER_NAME';
const SAVE_USER_EMAIL = 'SAVE_USER_EMAIL';
const SAVE_USER_ADDRESS = 'SAVE_USER_ADDRESS';

export const reducer = (state, { type, payload }) => {
    const actionTypes = {
        [SAVE_USER_NAME]: () => ({
            ...state,
            name: payload,
        }),
        
        [SAVE_USER_EMAIL]: () => ({
            ...state,
            email: payload,
        }),
        
        [SAVE_USER_ADDRESS]: () => ({
            ...state,
            address: payload,
        }),
    };

    return actionTypes[type] ? actionTypes[type]() : state;
}; We’ve created object, where a key is our action type and value is a function. Then we check, if such a key exists - we execute the function, else - we just return the initial state. I personally like this approach. It looks elegant and easy to read. actionTypes What do you think of this way? Do you use such an approach or maybe something else? P.S: It’s my first article, so I hope that it will be interesting and don’t throw tomatoes at me 😄

React: Redux Reducer With Object

Reaccionar: Reductor de redux con objeto

When writing complex projects, it’s essential to develop a good code culture. Usage of immutable and consistent objects is one of the most important ones. You can neglect this and write complex objects as standard ones, but it will be a significant source of bugs when the project grows enough. In my previous , I’ve shown how we can improve the consistency and reliability of standard objects. In a few words: article Add validations when setting values Use for each nullable field java.util.Optional Place complex mutations in a proper place - to the responsible class itself. But those actions are not enough to make fully reliable objects. In this article, I’ll show how to make objects immutable and make them eloquently and efficiently. The Problem If we make a simple serializable object with default constructor/getters/setters, it’s OK to make it the standard way. But let’s assume we write something more complex. And most likely, it’s used throughout countless places. For example, it’s used in HashMaps and maybe in a multi-threading environment. So, it doesn’t seem like a good idea anymore - to write it the default way. is not a big deal, and an inconsistent state between threads won’t make wait long. Breaking HashMap The first that come to mind when thinking about making immutable objects are: things Do not make setter methods Make all fields final Don’t share instances to mutable objects Do not allow subclasses to override methods (I will omit it in this article) But how to live with that kind of object? When we need to change it, we need to make a copy; how can we do it well without copy-pasting code and logic every time? A few words about our example classes Let’s say we have Accounts. Each account has an , , and . Accounts can be verified via email. When the status is , we do not expect the email to be filled. But when it is or , the email must be filled. id status email CREATED VERIFIED INACTIVE public enum AccountStatus {
    CREATED,
    VERIFIED,
    INACTIVE
} The canon implementation: Account.java public class Account {

    private final String id;
    private final AccountStatus status;
    private final String email;

    public Account(String id, AccountStatus status, String email) {
        this.id = id;
        this.status = status;
        this.email = email;
    }

    // equals / hashCode / getters

} Let’s imagine we’ve created an account. Then, somewhere in business logic, we need to change an email. var account = new Account("some-id", CREATED, null); How can we do that? The default way won’t work, we can’t have setters with an immutable class. account.setEmail("example@example.com");// we can not do that, we have no setters The only way to do that is to create a new instance and place to constructor previous values: var withEmail = new Account(account.getId(), CREATED, "example@example.com"); But it’s not the best way to change a field’s value, it produces so much copy/paste, and the Account class isn’t responsible for its consistency. Solution The suggested solution is to provide mutation methods from the Account class and implement copying logic inside the responsible class. Also, it’s essential to add required validations and usage of Optional for the email field, so we won’t have NPE or consistency problems. To build an object, I use the ‘Builder’ pattern. It’s pretty famous, and there are plenty of plugins for your IDE to generate it automatically. public class Account {

    private final String id;
    private final AccountStatus status;
    private final Optional<String> email;

    public Account(Builder builder) {
        this.id = notEmpty(builder.id);
        this.status = notNull(builder.status);
        this.email = checkEmail(builder.email);
    }

    public Account verify(String email) {
        return copy()
                .status(VERIFIED)
                .email(of(email))
                .build();
    }

    public Account changeEmail(String email) {
        return copy()
                .email(of(email))
                .build();
    }

    public Account deactivate() {
        return copy()
                .status(INACTIVE)
                .build();
    }

    private Optional<String> checkEmail(Optional<String> email) {
        isTrue(
                notNull(email).map(StringUtils::isNotBlank).orElse(false) || this.status.equals(CREATED),
                "Email must be filled when status %s",
                this.status
        );
        return email;
    }


    public static final class Builder {

        private String id;
        private AccountStatus status;
        private Optional<String> email = empty();

        private Builder() {
        }

        public static Builder account() {
            return new Builder();
        }

        public Builder id(String id) {
            this.id = id;
            return this;
        }

        public Builder status(AccountStatus status) {
            this.status = status;
            return this;
        }

        public Builder email(Optional<String> email) {
            this.email = email;
            return this;
        }

        public Account build() {
            return new Account(this);
        }
    }

    // equals / hashCode / getters

} As you can see, there is a private method in our class that returns with an exact copy. That removes copy-pasting of all fields, however, it’s crucial that this method is not accessible from outside because, with that Builder outside, we lose control over the state and consistency. copy Builder Account.java Changing accounts in a new way Now, let’s create an account: var account = account()
        .id("example-id")
        .status(CREATED)
        .email((empty())
        .build(); When we need to change an email, we don’t need to be responsible for creating a copy, we simply call a method from itself: Account var withNewEmail = account.changeEmail("new@new.com"); Demonstration of that in a unit test: @Test
void should_successfully_change_email() {
    // given
    var account = account()
            .id("example-id")
            .status(VERIFIED)
            .email(of("old@old.com"))
            .build();
    var newEmail = "new@new.com";

    // when
    var withNewEmail = account.changeEmail(newEmail);

    // then
    assertThat(withNewEmail.getId()).isEqualTo(account.getId());
    assertThat(withNewEmail.getStatus()).isEqualTo(account.getStatus());
    assertThat(withNewEmail.getEmail()).isEqualTo(of(newEmail));
} To verify an account, we don’t create a copy with status and a new email. We simply call the method , which not only will it create a copy for us, but will also check the validity of an email. VERIFIED verify @Test
void should_successfully_verify_account() {
    // given
    var created = account()
            .id("example-id")
            .status(CREATED)
            .build();
    var email = "example@example.com";

    // when
    var verified = created.verify(email);

    // then
    assertThat(verified.getId()).isEqualTo(created.getId());
    assertThat(verified.getStatus()).isEqualTo(VERIFIED);
    assertThat(verified.getEmail().get()).isEqualTo(email);
} Conclusion Living with immutable, consistent, and reliable objects is harsh, but in the proper way, it can become a lot easier. When implementing one, : don’t forget to Make all fields final Not provide setters Not share links to mutable objects Do not allow subclasses to override methods Provide mutation methods from your class Implement the method inside the responsible class that returns a , and use it to create new instances inside your class. private copy Builder Maintain consistency of fields by using validations on values Use with nullable fields Optional You can find the fully working example with more unit tests on . GitHub Lead Photo by on Adam Nieścioruk Unsplash

Learn How to Live with Immutable and Reliable Objects in Java

Aprenda a vivir con objetos inmutables y confiables en Java

Apprenez à vivre avec des objets immuables et fiables en Java

जावा में अपरिवर्तनीय और विश्वसनीय वस्तुओं के साथ जीना सीखें

Java で不変で信頼できるオブジェクトを扱う方法を学ぶ

Aprenda a viver com objetos imutáveis e confiáveis em Java

Học cách sống với các đối tượng bất biến và đáng tin cậy trong Java

学习如何在 Java 中使用不可变和可靠的对象

Object-Oriented Programming (OOP) languages, like JavaScript and Python, organize software design around data that is formatted in objects, rather than function or logic. First, I’ll cover the basics: objects, classes, instance, and methods. Then, I’ll briefly explain the four main pillars of OOP design: Encapsulation, Abstraction, Inheritance, and Polymorphism. Objects An object is data formatted to represent a real-world object that has a state and behavior. Picard’s state would be “wants to set a course” and his behaviors would be telling an ensign the desired course and to “Make it so.” Classes Different programming languages go about this in different ways, but essentially a class is a blueprint for creating an object. Instance Any time an object is created it is instantiated. Each deskSponge shown here would be an instance of an object and because they’re made with the class, an instance of . Spongebob Spongebob Methods Methods are functions within an object. In other words, our object’s behaviors. The coffee machine above would have a method for making coffee and the button would call it. The office worker would have a method for pushing the button, drinking the coffee, and caffeinated typing. Encapsulation You don’t need to know how the coffee machine works to press the button and get coffee. In other words, the behavior and state of the object in question should be private and only affected by private methods within the object. (The person who pressed the button doesn’t see the water being heated and pushed through the coffee grounds.) The object should have public methods that other objects can use to interact with it (like the button). Abstraction The only information about an object that is available outside the object is information absolutely necessary for other objects to use it. ![A seagull and crab discuss the crab's mysterious journey in a small row boat, ending with "any details will remain a mystery."](https://cdn.hackernoon.com/images/6sWrtbrOmsOIbrWzrG88lYfV4ch1-a7d3qce.png) This is also referred to as , and the public methods made available for other objects are “getters” and “setters.” information hiding Inheritance Just like genetics — if a class was a dog and each object inheriting from the dog class was a puppy. Objects made with a class (JavaScript uses the keyword ) inherit the information and methods of the super (or parent) class (calling in the in a JavaScript object). extends super() constructor Polymorphism and both have a method called . When is called, will put on his ascot, and will put on his ghost costume. Fred ghostFred getDressed() getDressed() Fred ghostFred In this case, is the class, and is an object that extends . inherits the method from , but when is instantiated, the programmer passes different arguments to and/or changes the method’s code. Fred ghostFred Fred ghostFred getDressed() Fred ghostFred getDressed() The OOP language evaluates which to use based on which object is being referenced when it is called (the object the keyword would refer to). Used correctly, this can significantly cut down on repeated code. Conclusion getDressed() this If you’re an experienced developer, hopefully you got a chuckle out of this. If you’re a beginner, I hope it helps you use an OOP language more confidently! If you enjoyed this high-level overview of OOP in memes or it left you with more questions, leave a comment! Also published here.

How to Use Memes to Understand Object Oriented Programming 

Cómo usar los memes para entender la programación orientada a objetos

How do autonomous vehicles see? You’ve probably heard of or other weird cameras they are using. But how do they work, how can they see the world, and what do they see exactly compared to us? Understanding how they work is essential if we want to put them on the road, primarily if you work in the government or build the next regulations. But also as a client of these services. LiDAR sensors We previously covered , but they are different from conventional autonomous vehicles. Tesla only uses cameras to understand the world, while most of them, like , use regular cameras and 3D LiDAR sensors. These LiDAR sensors are pretty simple to understand: they won’t produce images like regular cameras but 3D . LiDAR cameras measure the distance between objects, calculating the pulse laser’s traveling time that they project to the object. how Tesla autopilot sees and works Waymo point clouds Still, how can we efficiently combine this information and have the vehicle understand it? And what does the vehicle end up seeing? Only points everywhere? Is it enough for driving on our roads? We will look into this in the video with a new research paper by Waymo and Google Research... Watch the video! References ► Read the full article: ►Piergiovanni, A.J., Casser, V., Ryoo, M.S. and Angelova, A., 2021. 4d-net for learned multi-modal alignment. In Proceedings of the IEEE/CVF International Conference on Computer Vision (pp. 15435–15445). ►Google Research's blog post: ►My Newsletter (A new AI application explained weekly to your emails!): https://www.louisbouchard.ai/waymo-lidar/ https://openaccess.thecvf.com/content/ICCV2021/papers/Piergiovanni_4D-Net_for_Learned_Multi-Modal_Alignment_ICCV_2021_paper.pdf https://ai.googleblog.com/2022/02/4d-net-learning-multi-modal-alignment.html?m=1 https://www.louisbouchard.ai/newsletter/ Video transcript 0:00 how do autonomous vehicles see you've 0:02 probably heard of lidar sensors or other 0:05 weird cameras they are using but how do 0:07 they work how can they see the world and 0:09 what do they see compared to us 0:11 understanding how they work is essential 0:13 if we want to put them on the road 0:15 especially if you work in the government 0:17 or build the next regulations but also 0:20 as a client of these services we 0:22 previously covered how tesla autopilot 0:24 sees and works but they are different 0:26 from conventional autonomous vehicles 0:28 tesla only uses cameras to understand 0:31 the world while most of them like waymo 0:33 use regular cameras and 3d lidar sensors 0:38 these lidar sensors are pretty simple to 0:40 understand they won't produce images 0:42 like regular cameras but 3d point clouds 0:46 lidar cameras measure the distance 0:48 between objects calculating the pulse 0:50 lasers traveling time that they project 0:52 to the object this way they will produce 0:54 a very few data points with valuable and 0:57 exact distance information as you can 1:00 see here these data points are called 1:02 point clouds and it just means that what 1:04 we will see are just many points at the 1:06 right positions creating some sort of 3d 1:09 model of the world here you can see how 1:12 lidar on the right isn't that precise to 1:14 understand what it sees but it's pretty 1:16 good to understand that with very little 1:18 information which is perfect for 1:20 efficiently computing the data in real 1:22 time an essential criteria for 1:25 autonomous vehicles this minimal amount 1:27 of data and high spatial precision is 1:30 perfect because coupled with rgb images 1:33 as shown on the left we have both 1:35 accurate distance information and the 1:37 accurate object information we lack with 1:40 lidar data alone especially from far 1:43 away objects or people 1:44 this is why waymo and other autonomous 1:47 vehicles companies use both kinds of 1:49 sensors to understand the world still 1:52 how can we efficiently combine this 1:53 information and have the vehicle 1:55 understand it and what does the vehicle 1:58 end up seeing only points everywhere is 2:01 it enough for driving on the roads we 2:03 will look into this with a new research 2:05 paper by waymo and google research 2:08 to release many advancements like this 2:10 one the researchers needed to run many 2:13 many experiments and be super organized 2:16 plus their code needs to be easily 2:18 reproducible and near perfection as many 2:21 people will depend on it in life or 2:23 death situations fortunately these are 2:26 two strong points of this episode 2:28 sponsor weights and biases if you want 2:31 to publish papers in big conferences or 2:33 create the future of autonomous vehicles 2:36 i think using weights and biases will 2:38 certainly help it changed my life as a 2:40 researcher and for my work at design 2:42 stripe weights and biases will 2:44 automatically track each run the hyper 2:46 parameters the github version hardware 2:48 and os used then you can easily create 2:51 your own workspace using filters groups 2:54 and your own panels to display anything 2:56 you need to analyze how can you not be 2:59 well organized with such a tool it 3:01 basically contains everything you need 3:03 for your code to be reproducible without 3:06 you even trying for your future 3:08 colleagues and people that will 3:09 implement your amazing work please take 3:12 the time to ensure your work is 3:14 reproducible and if you want help with 3:16 that try out weights and biases with the 3:18 first thing we do 3:21 i think i couldn't summarize the paper 3:23 better than the sentence they used in 3:25 their article we present fortinet which 3:28 learns how to combine 3d point clouds in 3:31 time and rgb camera images in time for 3:34 the widespread application of 3d object 3:37 detection in autonomous driving i hope 3:39 you enjoyed the video please subscribe 3:41 and i'm just kidding let's dive a little 3:43 deeper into this sentence this is what 3:45 the 3d object detection we are talking 3:47 about looks like and it's also what the 3:50 car will end up seeing it's a very 3:52 accurate representation of the world 3:54 around the vehicle with all objects 3:56 appearing and precisely identified how 3:59 cool does that look and more interesting 4:02 how did they end up with this result 4:04 they produced this view using lidar data 4:07 called point clouds in time or pcit and 4:10 regular cameras are here called rgb 4:13 videos these are both four dimensional 4:16 inputs just like we humans see and 4:19 understand the world the four dimensions 4:21 come from the video being taken in time 4:24 so the vehicle has access to past frames 4:26 to help understand context and objects 4:28 to guess future behaviors just like we 4:31 do creating the fourth dimension the 4:34 three others are the 3d space we are 4:36 familiar with we call this task scene 4:39 understanding and has been widely 4:41 studied in computer vision and has seen 4:43 many advancements with the recent 4:45 progress of the field and machine 4:46 learning algorithms it's also crucial in 4:49 self-driving vehicles where we want to 4:51 have a near perfect comprehension of the 4:54 scenes here you can see that the two 4:56 networks always talk to each other with 4:59 connections this is mainly because when 5:01 we take images we have objects at 5:03 various ranges in the shot and with 5:05 different proportions the car in front 5:08 will look much bigger than the car far 5:10 away but we still need to consider both 5:13 like us when we see someone far away and 5:15 feel like it's our friend but still wait 5:17 closer to be sure before calling his 5:19 name the car will lack details for such 5:22 far away objects to patch for that we 5:24 will extract and share information from 5:26 different levels in the network sharing 5:29 information throughout the network is a 5:31 powerful solution because neural 5:33 networks use small detectors of fixed 5:36 size to condense the image the deeper we 5:38 get into the network meaning that early 5:41 layers will be able to detect small 5:42 objects and on the edges or parts of the 5:45 bigger objects deeper layers will lose 5:48 the small objects but be able to detect 5:50 large objects with great precision the 5:52 main challenge with this approach is 5:54 combining these two very different kinds 5:56 of information through these connections 5:58 the lidar 3d space data and more regular 6:01 rgb frames using both information at all 6:04 network steps as described earlier is 6:07 best to understand the whole scene 6:08 better but how can we merge two 6:10 different streams of information and use 6:13 the time dimension efficiently this data 6:15 translation between the two branches is 6:17 what the network learns during training 6:20 in a supervised way with a similar 6:22 process as in the self-attention 6:24 mechanisms i covered in previous videos 6:26 by trying to recreate the real model of 6:29 the world but to facilitate this data 6:31 translation they use a model called 6:33 point pilers which takes point clouds 6:36 and gives a two-dimensional 6:37 representation you can see this as a 6:40 pseudo image of the point cloud as they 6:42 call it creating somewhat of a regular 6:44 image representing the point cloud with 6:46 the same properties as the rgb images we 6:49 have in the other branch instead of the 6:51 pixels being red green blue colors they 6:54 simply represent the depth and positions 6:56 of the object x y z coordinates this 6:59 pseudo image is also really sparse 7:01 meaning that the information on this 7:03 representation is only dense around 7:05 imported objects and most probably 7:07 useful for the model regarding time as i 7:10 said we simply have the fourth dimension 7:12 in the input image to keep track of the 7:14 frames these two branches we see are 7:16 convolutional neural networks that 7:18 encode the images as described in 7:20 multiple of my videos and then decode 7:23 this encoded information to recreate the 7:25 3d representation we have here so it 7:28 uses a very similar encoder for both 7:30 branches shares information with each 7:33 other and reconstructs a 3d model of the 7:35 world using a decoder and voila this is 7:39 how the weimo vehicles see our world it 7:42 can process 32 point clouds in time and 7:45 16 rgb frames within 7:47 164 milliseconds producing better 7:50 results than other methods this might 7:53 not ring any bell so we can compare it 7:55 with the next best approach that is less 7:58 accurate and takes 300 milliseconds 8:00 almost double the time to process 8:03 of course this was just an overview of 8:05 this new paper by google research and 8:07 weymouth i'd recommend reading the paper 8:10 to learn more about their models 8:11 architecture and other features i didn't 8:14 dive into like time information's 8:16 efficiency problem it's linked in the 8:18 description below i hope you enjoyed the 8:20 video and if you did please consider 8:22 subscribing to the channel and 8:24 commenting what you think of this 8:26 summary i'd love to read what you think 8:29 thank you for watching and i will see 8:31 you next week with another amazing paper 8:35 [Music]

How Waymo Combines Lidar and Cameras for 3D Object Detection

Cómo Waymo combina Lidar y cámaras para la detección de objetos 3D

var obj = new CallableObject(); obj(args); A callable object is a data structure that behaves as both an object and a function. You can access and assign properties , call methods , but also call the object directly , as if it were a function. obj.bar obj.foo() obj() The direct call is like calling a method of which has access to the object’s properties through its . obj this context If you have experience with Python you’ll recognize this, there is a builtin Python protocol using the class method. Any method assigned to can be accessed as or as . __call__ __call__ obj.__call__() obj() Callable Objects can also be thought of as stateful functions. Functions are inherently single instance, stateless procedures. Callable Objects are instantiated, stateful procedures. In JavaScript almost everything is an object, including functions, so surely we can do this, but how? It’s not built in to the language like Python, but there are several ways to make it work. The Challenge Taking inspiration from Python, we want to create a Class / constructor that we can use to create callable objects that redirect their calls to a method named . We want this redirect so that we can inherit from our Class and easily override and extend the method with new functionality, without having to worry about the inner workings of the callable object. _call _call To do this, we’re going to need to inherit from the constructor, which inherits from , and allows us to create both an object and a dynamic function. Function Object Our main hurdle is giving a function object a reference to itself. In order to have a reference to the method, the function part of our function object, generated by our Callable class / constructor, must have a reference to itself. _call The Solutions We want to create an extensible class that  maintains proper and correct inheritance in JavaScript, and allows us to call the objects it constructs as functions, with a reference to themselves, redirecting those calls to an overridable method . Callable _call The Bind Way { () { ( , ) ._bound = .bind( ) ._bound
  }
  
  _call(...args) { .log( , args)
  }
} 'use strict' class Callable extends Function constructor super '...args' 'return this._bound._call(...args)' // Or without the spread/rest operator: // super('return this._bound._call.apply(this._bound, arguments)') this this this return this console this Try it out on repl.it Because we’re inheriting from we can create dynamic functions from strings, using in our constructor. So the string we pass to will be the body of our function. We want that function to be able to access its own object and call a method , passing on its arguments. We do this using . Function super super _call bind The bind method will allow us to set the context of a function to whatever we want, by wrapping that function in a transparent bound function. So we bind the function to itself with . this this.bind(this) Now our callable object has a reference to itself, except the object we return from our constructor, returned by , is a wrapped version of our original object. So all our properties will be attached to that, new, wrapped function object, and our function has a reference to the old  object passed to . this.bind bind The easy solution to this is to attach a reference to the new wrapped object on the old object as . And the body of our function, in the string passed to , simply calls using the reference. _bound super _call this._bound Pros Doesn’t rely on deprecated or modern features. No need to modify prototypes. Cons Requires wrapping the function object in a bound function. The Callee Way { () { ( ) }
  
  _call(...args) { .log( , args)
  }
} 'use strict' class Callable extends Function constructor super 'return arguments.callee._call.apply(arguments.callee, arguments)' // We can't use the rest operator because of the strict mode rules. // But we can use the spread operator instead of apply: // super('return arguments.callee._call(...arguments)') console this Try it out on repl.it Again we use the call to create a dynamic function, but his time we get our reference to the function itself by taking advantage of another implicit variable inside a function, the object. super arguments The arguments object has a property that is a reference to the called function. We use this reference as the first argument to which binds the functions context to itself. arguments.callee apply this So inside the function body, the string passed to super, we only need to call the method on . _call arguments.callee Pros Very simple. No need to modify prototypes. Cons and are unavailable in ‘strict mode’, see for more. arguments arguments.callee MDN Modern code should avoid for the / operator. arguments spread rest The Closure & Prototype Way { () { closure = { closure._call(...args) } .setPrototypeOf(closure, .target.prototype)
  }
  
  _call(...args) { .log( , args)
  }
} 'use strict' class Callable extends Function constructor var ( ) function ...args return // Or without the spread/rest operator: // var closure = function() { //   return closure._call.apply(closure, arguments) // } return Object new console this Try it out on repl.it Here instead of creating a dynamic function with , we discard the function object created by the constructor ( the object ), and replace it with a , by returning it instead of from the . super this closure this constructor The closure is also a function object, and can reference itself in its body through the closed over variable. We use the reference to redirect calls to its method . closure closure _call But we’ve broken the prototype chain by replacing with , so we reattach the prototype of the constructor to using and (which is a reference to the constructor) to get the prototype. this closure closure Object.setPrototypeOf new.target You can use instead of , but then you must first call to create the object, which is wasteful. this.constructor.prototype new.target.prototype super this Pros Requires no wrapping of the returned object with a or . Proxy bind Cons Requires modifying prototypes. Modifying prototypes is slow and has other side effects, see . MDN The Proxy Way { () { () ( , { : target._call(...args)
    })
  }
  
  _call(...args) { .log( , args)
  }
} 'use strict' class Callable extends Function constructor super return new Proxy this apply ( ) => target, thisArg, args console this Try it out on repl.it Using we can intercept calls to a function, using the trap, and redirect it to another function. The trap gives our callable a reference to itself as the argument. Proxy apply apply target So we create a Class that inherits from Function, , wrapping the callable objects created in a , trapping any calls made to those objects, and redirecting them to the method on the object itself, using the reference. Callable Proxy _call target Pros Simple, native way to intercept calls and redirect them. No need to modify prototypes. Cons Requires wrapping objects created by in a . Callable Proxy A small performance penalty for using handlers. Proxy What We Learned JavaScript is a remarkably flexible language, and you can bend it into many interesting shapes, like Callable Objects. There may well be use cases for Callable Objects, but in general I wouldn’t recommend using them, it’s not idiomatic JavaScript, and might be confusing or unclear to anyone else using your code. This was mostly just an interesting exercise. References: https://stackoverflow.com/questions/36871299/how-to-extend-function-with-es6-classes/40878674#40878674

Creating Callable Objects in JavaScript

Creación de objetos invocables en JavaScript

Stories, News & Mentions about OBSETO

Obseto’s Stories on HackerNoon