DataZoo

datazoo

The most used chart library for writing chart-related requirements is . echarts The performance of echarts on the website is quite mature, and the official solution is provided for the applet side, but there is no corresponding support in RN. On the market, most of the search is still based on the essence of the webview implementation, and I prefer the RN-based program. After all, the native experience will be better than the Web. Later, I found to meet me needs, so try it out; the results are not bad. For those interested in the principle of implementation, click @wuba/react-native-echarts here Tips If you already have an APP package, you can ignore the previous packaging process and start directly from step 4. The full code for the trial is on GitHub at: https://github.com/iambool/TestApp The steps to use it are as follows Step 1. Development environment setup This is the process of building a local RN development environment which is already available on the Internet, so I won't go over it again. You can search for it on Google :) Step 2. Creating an RN project As it was a trial, I used the expo to newly initialize an rn project called TestApp. npx create-expo-app TestApp Step 3. Building an app on mobile devices Generate ios and android app packages with a command line. iOS is recommended to use the emulator (no need to match the certificate). While on Android, I was connected to the real machine. yarn android
yarn ios After generating the package, the app like the one below is already installed on the phone, which means it is successful. Step 4. Install related dependencies yarn add @wuba/react-native-echarts echarts
yarn add @shopify/react-native-skia
yarn add react-native-svg Note: if you are installing in an existing project, you have to build a new package after the installation is complete, otherwise the lack of native dependencies will report an error. Step 5. Try the Skia model @wuba/react-native-echarts supports two , try a simple chart with Skia first. rendering modes (Skia and Svg) It's divided into these small steps： Introduce echarts, chart components and other dependencies. Registering chart components. Create a chart instance and set an option. Synchronized destruction of chart instances when the page is destroyed. The specific code is as follows: import { useRef, useEffect } from 'react';
import { View } from 'react-native';
/**
 * 1. Import the echarts dependency, this example first tries the line chart
 */
import * as echarts from 'echarts/core';
import { LineChart } from 'echarts/charts';
import { GridComponent } from 'echarts/components';
import { SVGRenderer, SkiaChart } from '@wuba/react-native-echarts';

/**
 * 2. Register the required components
 * SVGRenderer: it is required to register
 * LineChart: because we want to show the line chart, we have to import LineChart
 *      - If you don't know which components to import, just look at the error report and add whatever the error says is missing
 * GridComponent: This is the prompt when the error is reported, and then I added the, ha ha
 */
echarts.use([SVGRenderer, LineChart, GridComponent]);

export default () => {
  const skiaRef = useRef(null); // Ref for saving chart instances
  useEffect(() => {
    /**
     * 3. chart option
     */
    const option = {
      xAxis: {
        type: 'category',
        data: ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun'],
      },
      yAxis: {
        type: 'value',
      },
      series: [
        {
          data: [150, 230, 224, 218, 135, 147, 260],
          type: 'line',
        },
      ],
    };
    let chart;
    if (skiaRef.current) {
      /**
       * 4. Initialize the chart, specifying the lower width and height
       */
      chart = echarts.init(skiaRef.current, 'light', {
        renderer: 'svg',
        width: 400,
        height: 400,
      });
      chart.setOption(option);
    }
    /**
     * 5. To destroy the chart instance after the page is closed
     */
    return () => chart?.dispose();
  }, []);
  return (
    <View className='index'>
      <SkiaChart ref={skiaRef} />
    </View>
  );
}; After writing the code, shaking the phone and reloading the bundle package, an error was reported: ERROR Invariant Violation: requireNativeComponent: "SkiaDomView" was not found in the UIManager. I googled it and it says it requires a . It should correspond to the expo version, there will be a similar prompt when installing the dependency, install the prompted version and it will be fine. version downgrade So I followed the instructions and did a version downgrade: @shopify/react-native-skia@0.1.157
react-native-svg@13.4.0 It loaded up after rebuilding the app, which was nice. (but Android covers up the point, it seems that the screen width should be adaptive.) iOS Android Step 6. Try the Svg model Write a more complex dynamic sorting bar chart with Svg mode, and compare Svg and Skia. The full code is 。 here // ...Some unimportant code is omitted here

// Register the required components, such as BarChart and LegendComponent
echarts.use([SVGRenderer, BarChart, LegendComponent, GridComponent]);

export default () => {
  const skiaRef = useRef(null);
  const svgRef = useRef(null);

  useEffect(() => {
    // Skia mode
    const skiaChartData = getData(); // Generate chart bar data
    let skiaChart;
    let skiaInter;
    if (skiaRef.current) {
      skiaChart = echarts.init(skiaRef.current, 'light', {
        renderer: 'svg',
        width: 300,
        height: 300,
      });
      skiaChart.setOption(getDefaultOption(skiaChartData));
      setTimeout(function () {
        run(skiaChart, skiaChartData);
      }, 0);
      skiaInter = setInterval(function () {
        run(skiaChart, skiaChartData);
      }, 3000);
    }

    // Svg mode
    const svgChartData = getData();
    let svgChart;
    let svgInter;
    if (svgRef.current) {
      svgChart = echarts.init(svgRef.current, 'light', {
        renderer: 'svg',
        width: 300,
        height: 300,
      });
      svgChart.setOption(getDefaultOption(svgChartData));
      setTimeout(function () {
        run(svgChart, svgChartData);
      }, 0);
      svgInter = setInterval(function () {
        run(svgChart, svgChartData);
      }, 3000);
    }

    return () => {
      skiaChart?.dispose();
      svgChart?.dispose();
      // The timer has to be cleaned up, otherwise it will still run after exiting the page
      clearInterval(skiaInter);
      clearInterval(svgInter);
    };
  }, []);
  return (
    <View>
      <Text>skia</Text>
      <SkiaChart ref={skiaRef} />
      <Text>svg</Text>
      <SvgChart ref={svgRef} />
    </View>
  );
}; I can't see the difference between these two modes with my own eyes. iOS Android Step 7. Wrapping Chart Components So far the effect was quite good, but every time I used a bunch of things to import, It bothered me. Let's wrap it up simply: import { useRef, useEffect } from 'react';
import * as echarts from 'echarts/core';
import { BarChart, LineChart, PieChart } from 'echarts/charts';
import {
  DataZoomComponent,
  GridComponent,
  LegendComponent,
  TitleComponent,
  ToolboxComponent,
  TooltipComponent,
} from 'echarts/components';
import {
  SVGRenderer,
  SvgChart as _SvgChart,
  SkiaChart as _SkiaChart,
} from '@wuba/react-native-echarts';
import { Dimensions } from 'react-native';

// Register the required components
echarts.use([
  DataZoomComponent,
  SVGRenderer,
  BarChart,
  GridComponent,
  LegendComponent,
  ToolboxComponent,
  TooltipComponent,
  TitleComponent,
  PieChart,
  LineChart,
]);

// Default width and height of the chart
const CHART_WIDTH = Dimensions.get('screen').width; // Default with the phone screen width
const CHART_HEIGHT = 300;

const Chart = ({
  option,
  onInit,
  width = CHART_WIDTH,
  height = CHART_HEIGHT,
  ChartComponent,
}) => {
  const chartRef = useRef(null);

  useEffect(() => {
    let chart;
    if (chartRef.current) {
      chart = echarts.init(chartRef.current, 'light', {
        renderer: 'svg',
        width,
        height,
      });
      option && chart.setOption(option);
      onInit?.(chart);
    }
    return () => chart?.dispose();
  }, [option]);
  return <ChartComponent ref={chartRef} />;
};

const SkiaChart = (props) => <Chart {...props} ChartComponent={_SkiaChart} />;
const SvgChart = (props) => <Chart {...props} ChartComponent={_SvgChart} />;
// Just export these two guys
export { SkiaChart, SvgChart }; Step 8. Using multiple charts Once it’s wrapped, let’s write a page with multiple charts and see how it works. Here is a page for “e-commerce data analysis”, including a line chart, bar chart and pie chart. Below is the main code written with svg mode, click for detailed code. here import { SkiaChart } from '../../components/Chart';
import { ScrollView, Text, View } from 'react-native';
import { StatusBar } from 'expo-status-bar';
import { useCallback, useEffect, useState } from 'react';
import {
  defaultActual,
  lineOption,
  salesStatus,
  salesVolume,
  userAnaly,
  getLineData,
} from './contants';
import styles from './styles';
// Turn on chart loading
const showChartLoading = (chart) =>
  chart.showLoading('default', {
    maskColor: '#305d9e',
  });
// Close chart loading
const hideChartLoading = (chart) => chart.hideLoading();

export default () => {
  const [actual, setActual] = useState(defaultActual); // Recording real-time data

  useEffect(() => {
    // Assuming a recurring request for data
    const interv = setInterval(() => {
      const newActual = [];
      for (let it of actual) {
        newActual.push({
          ...it,
          num: it.num + Math.floor((Math.random() * it.num) / 100),
        });
      }
      setActual(newActual);
    }, 200);
    return () => clearInterval(interv);
  }, [actual]);

  const onInitLineChart = useCallback((myChart) => {
    showChartLoading(myChart);
    // Simulation of data requests
    setTimeout(() => {
      myChart.setOption({
        series: getLineData,
      });
      hideChartLoading(myChart);
    }, 1000);
  }, []);

  const onInitUserChart = useCallback((myChart) => {
    // Simulate data request, similar to onInitLineChart
  }, []);
  const onInitSaleChart = useCallback((myChart) => {
    // Simulate data request, similar to onInitLineChart
  }, []);
  const onInitStatusChart = useCallback((myChart) => {
    // Simulate data request, similar to onInitLineChart
  }, []);

  const chartList = [
    ['订单走势', lineOption, onInitLineChart],
    ['用户统计', userAnaly, onInitUserChart],
    ['各品类销售统计', salesVolume, onInitSaleChart],
    ['订单状态统计', salesStatus, onInitStatusChart],
  ];

  return (
    <ScrollView style={styles.index}>
      <StatusBar style='light' />
      <View>
        <View style={styles.index_panel_header}>
          <Text style={styles.index_panel_title}>实时数据</Text>
        </View>
        <View style={styles.index_panel_content}>
          {actual.map(({ title, num, unit }) => (
            <View key={title} style={styles.sale_item}>
              <View style={styles.sale_item_cell}>
                <Text style={styles.sale_item_text}>{title}</Text>
              </View>
              <View style={[styles.sale_item_cell, styles.num]}>
                <Text style={styles.sale_item_num}>{num}</Text>
              </View>
              <View style={[styles.sale_item_cell, styles.unit]}>
                <Text style={styles.sale_item_text}>{unit}</Text>
              </View>
            </View>
          ))}
        </View>
      </View>
      {chartList.map(([title, data, callback]) => (
        <View key={title}>
          <View style={styles.index_panel_header}>
            <Text style={styles.index_panel_title}>{title}</Text>
          </View>
          <View style={styles.index_panel_content}>
            <SkiaChart option={data} onInit={callback} />
          </View>
        </View>
      ))}
    </ScrollView>
  );
}; Reload the bundle and see the result iOS Android After rendering, the interaction on iOS is very smooth, while the interaction on Android feels occasionally laggy (not because my phone is too bad, right?...) Trying the Skia mode again… Well, although it can, it seems that Chinese can not be displayed properly, Android Chinese is not displayed, and iOS is a mess of code. After reading the documentation, skia currently does not support Chinese on the Android side, We can display Chinese on iOS by setting the font to ‘PingFang SC’, for example: const option = {
  title: {
    text: '我是中文',
    textStyle: {
      fontFamily: 'PingFang SC', // setting the font type
    },
  },
}; But every place that displays Chinese has to set the font... that or use Svg first, I'm lazy. Summary After using it for a while, I summarized the following: In terms of support, @wuba/react-native-echarts supports all types of charts except GL series and map charts which are not yet supported, which is very enough for daily business. The code to implement the various charts in echarts can be found in . taro-playground Interaction, iOS is very silky smooth, Android sometimes there are cases of frame drops. Performance: Performance is officially reported as better than other solutions. I tried it, not a very large amount of data will not have any problems, but when the amount of data is too large (such as drawing a large amount of data heat map), the rendering speed significantly decreased a lot, which is a point waiting for the official to optimize. In addition, if there are many charts on the page, the loading speed will be slow when debugging on the real machine, so it is recommended to use the simulator first. Chinese support, Svg mode supports Chinese, but Skia mode is not available yet. The above is only a personal view, any questions and comments are welcome below!

The Best Way to Do React Native Charting in 2023

La mejor manera de hacer gráficos nativos de React en 2023

La meilleure façon de faire React Native Charting en 2023

2023 में रिएक्टिव नेटिव चार्टिंग करने का सबसे अच्छा तरीका

2023 年に React Native Charting を行うための最良の方法

A melhor maneira de fazer gráficos nativos de reação em 2023

Cách tốt nhất để thực hiện React Native Charting vào năm 2023

2023 年 React Native 制图的最佳方式

How to Accurately Measure Binomial Proportions for Reliable Conversion Metrics

The Critical Role of Data Annotation in Shaping the Future of Generative AI

Крытычна важная роля анатацыі даных у фарміраванні будучыні генератыўнага ІІ

Критичната роля на анотирането на данни при оформянето на бъдещето на генериращия ИИ

Den kritiske rolle for dataannotering i at forme fremtiden for generativ AI

El papel fundamental de la anotación de datos en la configuración del futuro de la IA generativa

Le rôle crucial de l’annotation des données dans la définition de l’avenir de l’IA générative

Il ruolo critico dell'annotazione dei dati nel plasmare il futuro dell'intelligenza artificiale generativa

生成型 AI の未来を形作るデータ注釈の重要な役割

생성 AI의 미래를 형성하는 데 있어서 데이터 주석의 중요한 역할

Karolo ye Bohlokwa ya Tlhaloso ya Datha go Bopeng Bokamoso bja AI ya Tlhagišo

Rolul critic al adnotării datelor în modelarea viitorului IA generativă

Rozhodujúca úloha anotácie údajov pri formovaní budúcnosti generatívnej AI

Den kritiska rollen för datakommentarer i att forma framtiden för generativ AI

Some of us are faced with a situation where we need to create a web socket server that will distribute a message to all clients subscribed to an event. Most applications are built on a , which causes some peculiarities when creating a web socket server. microservice architecture Let's imagine a small system: Its work scenario is very simple. The user on the front end changes some data via the REST API, and the DataService notifies its subscribers that something has changed. Sounds simple, right? But what if we remember that all our services work through Kubernetes, which means that each of them can have several pods and DataService is no exception? This means that our circuit will look like this: Question: what happens if the frontend calls DataService (pod 2)? Will all subscribers receive notifications about data changes? If you do nothing, then only subscribers to pod 2 will receive messages, because under 1 is unaware of data changes. But we need subscribers of all pods to receive a notification. In this matter, socket.io adapters come to our aid. The simplest and one of the most popular of them is the Redis Adapter ( ). Implemented based on the pub/sub mechanism ( ). In short, a pod that has learned about data changes publishes a message about this in Redis, this message is read by other pods and sends a notification to its subscribers. https://socket.io/docs/v4/redis-adapter/ Redis https://redis.io/docs/interact/pubsub/ Let's try to test the Redis Adapter in a simple NestJs application. First, let's write a simple gateway. @WebSocketGateway()
export class WebSocketApiGateway {


   @WebSocketServer()
   server: Server;


   @SubscribeMessage('join')
   async join(@ConnectedSocket() client: Socket): Promise<void> {
       console.log(`web-socket api join`);
       client.join(Rooms.dataRoom);
       client.emit('join', 'successful join');
   }


   async updateData(data: DataDto): Promise<void> {
       console.log(`web-socket api emit data '${JSON.stringify(data)}'`);
       this.server.to(Rooms.dataRoom).emit(Rooms.dataRoom, data);
   }
} It will send a message to all subscribers when the function is called. Next, I created a controller and a service for updating data. @Controller('data')
export class DataController {
   constructor(
       private readonly dataService: DataService
   ) {
   }
   @Post()
   async createData(@Body() data: DataDto): Promise<void> {
       await this.dataService.createData(data);
   }
} @Injectable()
export class DataService{
   constructor(
       private readonly socketGateway: WebSocketApiGateway
   ) {
   }


   async createData(data: DataDto): Promise<void> {
       await this.socketGateway.updateData(data);
   }
} Here's some basic logic to help you focus on the main thing. Then I wrote client export let socketClient: Socket;


@Injectable()
export class WebSocketClient implements OnModuleInit, OnModuleDestroy {
   private readonly socket: Socket;


   private readonly onConnected?: () => void;


   constructor(
       options: Options,
       private readonly webSocketService: WebSocketService
   ) {
       this.socket = io(options.serverUrl,{
           reconnection: true,
           reconnectionDelay: 2000,
           autoConnect: true
       });


       socketClient = this.socket;


       this.onConnected = options.onConnected;


       this.socket.on('connect_error', (err) => {
           console.log('connect_error: ', undefined, err)
       });
   }


   onModuleInit(): void {
       this.connect();
   }


   onModuleDestroy(): void {
       this.socket.disconnect();
   }


   connect(): void{
       this.socket.on('join', (body: string): void => {
           if (this.onConnected) {
               this.onConnected();
           }


           console.log(`join message '${body}'`);
       });


       this.socket.on(Rooms.dataRoom, (data: DataDto): void => {
           console.log(`web-socket client on data '${JSON.stringify(data)}'`);
           this.webSocketService.updateData(data);
       });


       this.socket.on('connect', async () => {
           this.socket.emit('join');
           console.log('connected')
       });
   }


} Pay attention to the and variable. We will need them for tests. I will explain their purpose a little later. The main thing is that this client subscribes to room events and calls the method on the export service, which simply updates this data in inMemory. onConnected socketClient Rooms.dataRoom updateData @Injectable()
export class WebSocketService{
   private data: DataDto;


   updateData(data: DataDto): void{
       this.data = data
   };


   getData(): DataDto{
       return this.data;
   }
} Now the fun part - the redis adapter. I created the class - a descendant of , everything is as in the documentation. RedisIoAdapter IoAdapter export class RedisIoAdapter extends IoAdapter {
 private readonly adapterConstructor: ReturnType<typeof createAdapter>;


 constructor(app: INestApplication, connectionKeeper: RedisConnectionsKeeper) {
   super(app);


   const subClient = connectionKeeper.createConnect();
   const pubClient = connectionKeeper.createConnect();


   this.adapterConstructor = createAdapter(pubClient, subClient);
 }


 createIOServer(port: number, options?: ServerOptions): unknown {
   const server = super.createIOServer(port, options);


   server.adapter(this.adapterConstructor);


   return server;
 }
} And I connected it when creating our application async function bootstrap() {
   const app = await NestFactory.create(AppModule, {
       bufferLogs: true,
   });
   const connectionsKeeper = app.get(RedisConnectionsKeeper);
   app.useWebSocketAdapter(new RedisIoAdapter(app, connectionsKeeper));
   await app.listen(config.get('app.port'));
};


void bootstrap(); Look like that's it. But no! The difficulties began when writing tests for this code. In tests, I lift a container with redis to check the functionality of the adapter. Everything is typical here. export async function redisSetup(): Promise<StartedTestContainer> {
   const redisContainer = await new GenericContainer(REDIS_IMAGE)
       .withEnvironment({
           REDIS_PASSWORD,
           REDIS_DISABLE_COMMANDS: 'FLUSHDB,FLUSHALL',
       })
       .withExposedPorts(REDIS_PORT)
       .withWaitStrategy(Wait.forListeningPorts())
       .start();


   // (await redisContainer.logs())
   //   .on('data', (line) => console.log(line))
   //   .on('err', (line) => console.error(line))
   //   .on('end', () => console.log('Stream closed'));


   const redisPort = redisContainer.getMappedPort(REDIS_PORT);
   config.set('redis.host', 'localhost');
   config.set('redis.port', redisPort);
   config.set('redis.password', REDIS_PASSWORD);
   config.set('redis.db', REDIS_DB);


   return redisContainer;
} I call this function in , and in I do . This is where the first problem appears. The redis adapter uses connections to it that need to be closed. That's why I created the class, which stores these connections and closes them when the application is destroyed. beforeAll afterAll redisContainer.stop({ removeVolumes: true }) RedisConnectionsKeeper @Injectable()
export class RedisConnectionsKeeper implements OnModuleDestroy {
 private clients: Redis[] = [];


 async onModuleDestroy(): Promise<void> {
   for (const client of this.clients) {
     await client.quit();
   }
 }


 createConnect(): Redis {
   const client = new Redis({
     host: config.get('redis.host'),
     port: config.get('redis.port'),
     db: config.get('redis.db'),
     password: config.get('redis.password'),
   });
   client.on('error', (err) => {
     console.log(`redis client error ${`${err.message}`}`)
   });
   this.clients.push(client);


   return client;
 }
} Then the second problem emerged. In the test, the value check could occur BEFORE the socket logic is executed. It’s time to take the variable with the connection to the socket server outside and check that the message actually arrived. In the end my tests look like this: describe('websocket api gateway', () => {
   let redisContainer: StartedTestContainer;
   let appServer1: INestApplication;
   let appServer2: INestApplication;
   let appClient: INestApplication;


   beforeAll(async () => {
       redisContainer = await redisSetup();


       const server1Port = 3000;
       appServer1 = await initServer(server1Port);


       const server2Port = 4000;
       appServer2 = await initServer(server2Port);


       appClient = await initClient(`http://localhost:${server1Port}`);
   }, 15 * 1000);


   afterAll(async () => {
       await Promise.all([
           appServer1.close(),
           appServer2.close(),
           appClient.close(),
           redisContainer.stop({ removeVolumes: true }),
       ]);
   }, 15 * 1000);


   describe('join', () => {
       it('should update data, if new data created', async () => {
           const first = new Promise((resolve) => {
               socketClient.once(Rooms.dataRoom, resolve);
           });


           const data: DataDto = {
               data: 'hello'
           };


           const dataService: DataService = appServer1.get(DataService);
           await dataService.createData(data);


           await first;


           const webSocketService = appClient.get(WebSocketService);


           expect(webSocketService.getData().data).toBe(data.data);
       });


       it('should update data, if new data created on other server', async () => {
           const first = new Promise((resolve) => {
               socketClient.once(Rooms.dataRoom, resolve);
           });


           const data: DataDto = {
               data: 'hello'
           };


           const dataService: DataService = appServer2.get(DataService);
           await dataService.createData(data);


           await first;


           const webSocketService = appClient.get(WebSocketService);


           expect(webSocketService.getData().data).toBe(data.data);
       });
   });
}); That's all. Both of our tests worked great. In the first of them, I called the method for changing information on the server to which the client was subscribed, and in the second, the changes were called on another server. This shows that the adapter successfully copes with the task. Link to the project in GitHub - https://github.com/waksund/redis-adapter-example

How to Build a WebSocket Adapter In NestJs

Google Bard Shares Its Thoughts on UFOs, or UAPs, and Being an AI

Creating a Google Kubernetes Engine (GKE) Cluster with Terraform in a Custom VPC

AI is approaching the next level of maturity, coming out of the hype cycle, says Gartner. Its adoption is expanding across industries beyond automation to building new-generation intelligent products and services for business growth. Around 90% of companies in the US and UK view artificial intelligence as a priority, with AI projects either in planning or production. However, half of them acknowledge that they lack the skill to make the most of AI advances. This is where experienced AI consulting firms come in to help. The market of AI consulting is vast, ranging from tech giants like IBM and Accenture to Big 4 firms and smaller-scale innovators. Here, we’ve compiled a list of the top 10 AI consulting firms that have earned a reputation for disruptive innovations. These experts run product discovery and deliver proofs of concept (PoC) and MVPs. This way, they help organizations bring pioneering products and services to the market and build proprietary AI systems for transforming operations. Let’s explore these top AI consulting companies — they are worth their salt. In this blog, you will find an overview of each of them and useful tips on picking the right partner for your AI project. Our list of the top 10 AI consulting firms for 2023 1. ITRex is a full-cycle AI and big data solutions provider with teams in Poland, the US, and Mexico and a dedicated R&D lab where they design new AI concepts and build prototypes. They are tech savvy in all AI-related fields (ML, deep learning, NLP, and computer vision), delivering AI projects end to end, from preparing data for algorithms to rolling out systems to thousands of users. ITRex Having adopted a start-small-and-scale-up approach, ITRex helps Fortune 500 companies and startups launch breakthrough AI products, apart from automating operations, boosting customer experiences, and supporting smart decision-making. They’ve delivered quite a number of impressive AI projects, from an AI-powered big data platform for the world’s biggest retailer to a fitness mirror with a personal coach experience, an ML-based clinical decision support system for cancer patients, a SaaS cybersecurity solution using face recognition, and many others. Walmart, 21st Century Fox, and Warner Bros. Entertainment Inc. are just some of their big-name clients. Rates: $50 – $99/hr Size: 300+ Founded: 2009 Headquarters: Aliso Viejo, California 2. Deeper Insights The UK-headquartered is fully focused on providing AI consulting and development services, with its expertise spanning from AI exploration to ML engineering, NLP, and computer vision. As they say on their website, they solve their clients’ “impossible problems,” helping them achieve the desired business results. Deeper Insights The company develops custom AI algorithms and ML models using either their clients’ data sets or data collected via their proprietary ML web scraper – the Skim Engine™. They have delivered many innovative AI projects for big-ticket and smaller clients, including an automated insights app for sales teams at Deloitte, a custom media monitoring platform for the global real estate services company Jll, and bespoke computer vision algorithms integrated with deep learning to recognize body parts in images in robotic surgeries. Rates: $50-$99/hr Size: 10-49 Year: 2014 Headquarters: London, UK 3. InData Labs also specializes in AI consulting and implementation services. As most top AI consulting firms on our list, they offer not only advice but also AI R&D, PoCs, MVPs, and development of AI web/mobile apps, empowering clients with data science and AI technology. InData Labs The company helps clients leverage predictive analytics, NLP, computer vision, and intelligent automation to get meaningful insights from data, understand audiences, forecast demand, reduce risks, and eliminate cost overruns. Examples of their AI-powered solutions include a computer vision system for pose estimation in fitness, face recognition for a surveillance system, image analysis for ticket processing software, and many more. They’ve also delivered different kinds of predictive analytics systems for logistics, eCommerce, sports, entertainment, and healthcare, along with NLP tools for simultaneous interpreting, remote education, and sentiment analysis. Rates: $50-$99/hr Size: 80+ Year: 2014 Headquarters: Nicosia, Cyprus 4. Cambridge Consultants With over 20,000 sqm of R&F facilities and a 900-strong team, helps organizations develop AI-based products that “will transform how we live and the world around us.” Cambridge Consultants Being part of the French-based tech consultancy Capgemini, Cambridge Consultants is a big and established player on our top AI consulting firms list, operating since 1960. Cambridge Consultants is honored for AI breakthroughs in many fields across industries. Projects in their portfolio range from a drone delivery service to military robots using AI-based navigation and reinforcement learning, a proprietary crop spraying technology, an AI system for an automated response to cyberattacks built for the UK Ministry of Defence, and a piano music classification tool. Rates: Undisclosed Size: 900+ Year: 1960 Headquarters: Cambridge, UK 5. ThirdEye Data Based in Silicon Valley with delivery centers in the US and India, describes itself as a one-stop shop for data science, analytics, and engineering services. Apart from providing end-to-end big data and AI solutions, the company has developed its own open-source tools for anomaly detection and predictive analytics. ThirdEye Their expertise is recognized by multiple industry awards. Microsoft, Walmart, British Petroleum, and AWS are among their Fortune 500 clients. The company has implemented over 30 end-to-end data and AI projects, such as an image quality detection system for Southern California Edison, MLOps engineering for XPERI, and predictive metrology for Glas Trosch. Rates: $25 – $49 hr Size: 51 – 200 Founded: 2010 Headquarters: San Jose, California 6. LeewayHertz Operating since 2007, specializes in many AI fields, from ML and NLP to computer vision. Among its big-name clients are Procter & Gamble, McKinsey & Company, Siemens, and Hershey’s. LeewayHertz With the mission to help organizations adopt AI at scale, LeewayHertz has entered our top AI consulting firms list for delivering innovative AI solutions across sectors. Among its landmark projects in collaboration with an Indian food tech startup, which has resulted in the creation of the world’s first tea-making robot Arya using ML, speech recognition, and NLP. They’ve also built a computer vision-enabled marketplace for AI applications and an AI-based employee time-tracking app. Rates: $50-$99 hr Size: 51-249 Founded: 2007 Headquarters: San Francisco, California 7. DataRoot Labs is a fast-growing company with teams in Ukraine and Israel. As a top AI consulting firm, it helps ambitious startups and startup accelerators turn their boldest AI ideas into reality. DataRoot Labs DataRoot Labs prides itself on driving tech innovation by running the DataRoot University, which offers data engineering and data sciences courses. They have accomplished a great number of projects around computer vision and other AI technologies for clients, delivering, for instance, a solution for defect detection in solar panels, a personal coach app, an in-store customer activity tracking app, an empathetic virtual assistant, and many others. Rates: $51-$99/hr Size: 10-49 Founded: 2016 Headquarters: Kyiv, Ukraine 8. Azati Software Creating fully functional AI solutions since 2016, shares its expertise on a consultancy basis across AI fields, from supervised/unsupervised learning to NLP, computer vision, predictive analytics, and conversational AI. Azati Software Their featured AI-based projects include a data processing tool to analyze inputs from oil and gas meters using ML and computer vision, an ML model for pharmaceutical marketing, a semantic search engine to tap into scientific datasets, and an AI-powered app that changes the interior of smartphone pictures. With an R&D center in Poland, this top AI consulting firm successfully helps clients translate their AI vision into prototypes and MVPs. Rates: $25-$49/hr Size: 150 Founded: 2001 Headquarters: Warsaw, Poland 9. Tooploox The EU-based AI consultancy has built its AI expertise by working extensively with US startups, innovators, and VCs. Tooploox With the mission to improve people’s lives through cutting-edge technology, Tooploox has extensive R&D capabilities that have widened after the company joined forces with Microscope IT, a development shop offering AI-related services for healthcare, medtech, and life sciences. Their skillsets around AI now extend to computer and 3D vision, deep learning, sensor fusion, NLP, data capture & OCR, and beyond. Tooploox has been recognized for its research at international conferences, such as NIPS and ICML. They are also known for building Virtum, an AI-powered image analysis system that helps spot cancer cells. Rates: $100-$149/hr Size: 150 Founded: 2012 Headquarters: Warsaw, Poland 10. Addepto is another fast-growing company that deserves a spot on our list of top AI consulting firms. It was established in 2017 and now helps companies grow with the power of data and AI. Addepto With expertise in all data-related fields, the Addepto team has won the trust of a few Fortune 500 companies, which they support in creating complex AI solutions. Among them are Citibank and P&G. Addepto has helped build a digital twin monitoring airport operations, an intelligent passenger and baggage tracking system, a shipping schedule and inventory management system using predictive modeling for the world’s second-largest aluminum company, and an ML-powered demand forecasting tool for postal services. Rates: $50-$99/hr Size: 10-49 Year: 2017 Location: Warsaw, Poland How to choose your AI partner - Tips from the ITRex CTO Reducing a lot of options available in the AI consulting market to just a few should make life simpler. However, you still need to choose only one of them at the end of the day. What should you consider? We’ve asked ITRex CTO Kirill Stashevsky, who has over 15 years of experience helping companies deliver innovative solutions, to share his tips. Here they are: 1. Explore the vendor’s website to make sure they indeed offer AI consulting services, not just development. [ ] This can be especially helpful for those with little or no technical background. The thing is, an experienced consulting partner might figure out a more elegant tech solution for translating your vision into a reality. This solution can be cheaper, quicker, and more efficient than the one you had in mind. The latest AI breakthroughs can be fascinating, but it is useful to make sure first before any coding begins that they are exactly what you need to build a fascinating product. A good AI consulting firm would be happy to look at your vision from different perspectives and give you free advice over the phone. Don’t hesitate and ask for it first. 2. Look through the vendor’s portfolio to check if they delivered a similar solution in the past. [ ] Companies’ portfolios with featured projects or case studies are a great source of valuable information. They let you understand which clients they served and what projects they accomplished previously. It is best to reduce your list of top AI consulting firms to companies that have a demonstrable experience with what you are trying to achieve. These guys should know your domain well so you will speak the same language with them without having to waste time explaining the basics. They are also likely to know all the potential pitfalls that might be typically encountered on a journey like yours. However, don’t be too quick to strike off a vendor of your choice that doesn’t have the exact expertise you are looking for. The firm can still be a perfect fit for your project if they specialize in AI consulting services (see the first tip). 3. Do a bit of homework to define your business objectives clearly. [ ] Instead of contacting all the 10 or 20 companies on your top AI consulting firms list to discuss your future product, prepare a one-pager describing what you are trying to build from the business point of view, and send it out. Some vendors would reply they don’t know how to help; some might figure out how they can implement your idea best, while others might offer you cost-efficient customization of a tool already in the market. This way, you will narrow down your list quicker, saving time and energy. 4. Don’t forget about social proof [ ] Check out previous reviews from clients who partnered with the company and the company’s rating. This information can be found on sites like clutch.co or goodfirms.co. Ask your acquaintances, colleagues, and people you meet at hackathons and industry conferences — they might have heard something about a firm of your choice. You can also ask the vendor for feedback from their previous clients. Wrapping it up Artificial intelligence is already profoundly impacting our daily lives while transforming the business landscape. that AI could add more than $15 trillion to global GDP by 2030, meaning that it has the potential to change the way we live completely. Capitalize on the emerging trend and put your company at the front of the line by partnering with the right AI consulting firm. PwC estimates Originally published . here

Top 10 AI Consulting Firms Today

Deconstructing React 18 

TL;DR 🚌 We’ll write a lightweight Event Bus from scratch in just 60 lines! 🌱 We’ll learn the use case to best utilize Event Bus in React. 🏋️‍♀️ We’ll apply Event Bus in a demo with Google Maps API. I recently came across an interesting use case of Event Bus at work. It’s a very lean module to organize logging for analytics in a global-scale web application. It creates great clarity in a large code base so I want to share with you my case study of this useful design pattern. Let’s go. What Is An Event Bus? An Event Bus is a design pattern that allows PubSub-style communication between components while the components remain loosely coupled. A component can send a message to an Event Bus without knowing where the message is sent to. On the other hand, a component can listen to a message on an Event Bus and decide what to do with the message without knowing where the message comes from. With this design, independent components can communicate without knowing each other. The visualization looks like this: Event: The message being sent and received on an Event Bus. Publisher: The sender that an event. emits Subscriber: The receiver that to an event. listens Let’s take a closer look at Event Bus. Building An Event Bus from Scratch Inspired by , we’ll implement the following APIs for our Event Bus: Vue’s legacy Events API type EventHandler = (payload: any) => void

interface EventBus {
  on(key: string, handler: EventHandler): () => void
  off(key: string, handler: EventHandler): void
  emit(key: string, ...payload: Parameters<EventHandler>): void
  once(key: string, handler: EventHandler): void
} : for a subscriber to listen (subscribe) to an event and register its event handler. on : for a subscriber to remove (unsubscribe) an event and its event handler. off : for a subscriber to listen to an event only once. once : for a publisher to send an event to the event bus. emit Now, the data structure for our Event Bus should be capable of two things: For publishers: to be able to fire the registered event handlers associated with the event key when is called. emit For subscribers: to be able to add or remove event handlers when , , or is called. on once off We can use a key-value structure for it: type Bus = Record<string, EventHandler[]> To implement the method, all we need to do is to add the event key to the bus and append the event handler to the handler array. We also want to return an unsubscribe function to remove the event handler. on export function eventbus(config?: {
  // error handler for later
  onError: (...params: any[]) => void
}): EventBus {
  const bus: Bus = {}

  const on: EventBus['on'] = (key, handler) => {
    if (bus[key] === undefined) {
      bus[key] = []
    }
    bus[key]?.push(handler)

    // unsubscribe function
    return () => {
      off(key, handler)
    }
  }

  return { on }
} To implement , we can simply remove the event handler from the bus. off const off: EventBus['off'] = (key, handler) => {
  const index = bus[key]?.indexOf(handler) ?? -1
  bus[key]?.splice(index >>> 0, 1)
} When is called, what we want to do is to fire all the event handlers that associate with the event. We’ll add error handling here to make sure all the event handlers will be fired despite errors. emit const emit: EventBus['emit'] = (key, payload) => {
  bus[key]?.forEach((fn) => {
    try {
      fn(payload)
    } catch (e) {
      config?.onError(e)
    }
  })
} Since will only listen to an event exactly once, we can think of it as a method that registers a handler that deregisters itself after firing. One way to do it is to create a higher order function : once handleOnce const once: EventBus['once'] = (key, handler) => {
  const handleOnce = (payload: Parameters<typeof handler>) => {
    handler(payload)
    off(key, handleOnce as typeof handler)
  }

  on(key, handleOnce as typeof handler)
} Now we have all the methods in our Event Bus! Improve TypeScript Typing The current typing for the Event Bus is quite open-ended. The event key could be any string and the event handler could be any function. To make it safer to use, we can add type checking to add the event key and handler association to the . EventBus type EventKey = string | symbol
type EventHandler<T = any> = (payload: T) => void
type EventMap = Record<EventKey, EventHandler>
type Bus<E> = Record<keyof E, E[keyof E][]>

interface EventBus<T extends EventMap> {
  on<Key extends keyof T>(key: Key, handler: T[Key]): () => void
  off<Key extends keyof T>(key: Key, handler: T[Key]): void
  once<Key extends keyof T>(key: Key, handler: T[Key]): void
  emit<Key extends keyof T>(key: Key, ...payload: Parameters<T[Key]>): void
}

interface EventBusConfig {
  onError: (...params: any[]) => void
}

export function eventbus<E extends EventMap>(
  config?: EventBusConfig
): EventBus<E> {
  const bus: Partial<Bus<E>> = {}

  const on: EventBus<E>['on'] = (key, handler) => {
    if (bus[key] === undefined) {
      bus[key] = []
    }
    bus[key]?.push(handler)

    return () => {
      off(key, handler)
    }
  }

  const off: EventBus<E>['off'] = (key, handler) => {
    const index = bus[key]?.indexOf(handler) ?? -1
    bus[key]?.splice(index >>> 0, 1)
  }

  const once: EventBus<E>['once'] = (key, handler) => {
    const handleOnce = (payload: Parameters<typeof handler>) => {
      handler(payload)
      // TODO: find out a better way to type `handleOnce`
      off(key, handleOnce as typeof handler)
    }

    on(key, handleOnce as typeof handler)
  }

  const emit: EventBus<E>['emit'] = (key, payload) => {
    bus[key]?.forEach((fn) => {
      try {
        fn(payload)
      } catch (e) {
        config?.onError(e)
      }
    })
  }

  return { on, off, once, emit }
} Now we are instructing TypeScript that the has to be one of the and the handler should have the corresponding handler type. For example: key keyof T interface MyBus {
  'on-event-1': (payload: { data: string }) => void
}

const myBus = eventbus<MyBus>() You should be able to see a clear type definition when developing. Use The Event Bus in React I created a application to demonstrate how to use the Event Bus we just built. Remix You can find the . GitHub repository for the demo here The demo showcases how to organize logging with the Event Bus in an isomorphic React application. I picked three events to log: : the event happens when the map finishes instantiating or a user finishes dragging or zooming the map. onMapIdle : the event happens when a user clicks on the map. onMapClick : the event happens when a user clicks on a map marker. onMarkerClick Let’s create two . One for the map, and one for the marker. event channels import { eventbus } from 'eventbus'

export const mapEventChannel = eventbus<{
  onMapIdle: () => void
  onMapClick: (payload: google.maps.MapMouseEvent) => void
}>() import { eventbus } from 'eventbus'
import type { MarkerData } from '~/data/markers'

export const markerEventChannel = eventbus<{
  onMarkerClick: (payload: MarkerData) => void
}>() The reason to separate event channels is to create a clear separation of concerns. This pattern can grow horizontally when your application grows. Now, let’s use the event channels in React components. import { markers } from '~/data/marker'
import { logUserInteraction } from '~/utils/logger'
import { mapEventChannel } from '~/eventChannels/map'
import { markerEventChannel } from '~/eventChannels/marker'

export async function loader() {
  return json({
    GOOGLE_MAPS_API_KEY: process.env.GOOGLE_MAPS_API_KEY,
  })
}

export default function Index() {
  const data = useLoaderData()
  const portal = useRef<HTMLDivElement>(null)
  const [selectedMarker, setSelectedMarker] = useState<MarkerData>()

  useEffect(() => {
    // subscribe to events when mounting
    const unsubscribeOnMapIdle = mapEventChannel.on('onMapIdle', () => {
      logUserInteraction('on map idle.')
    })
    const unsubscribeOnMapClick = mapEventChannel.on(
      'onMapClick',
      (payload) => {
        logUserInteraction('on map click.', payload)
      }
    )
    const unsubscribeOnMarkerClick = markerEventChannel.on(
      'onMarkerClick',
      (payload) => {
        logUserInteraction('on marker click.', payload)
      }
    )

    // unsubscribe events when unmounting
    return () => {
      unsubscribeOnMapIdle()
      unsubscribeOnMapClick()
      unsubscribeOnMarkerClick()
    }
  }, [])

  const onMapIdle = (map: google.maps.Map) => {
    mapEventChannel.emit('onMapIdle')

    setZoom(map.getZoom()!)
    const nextCenter = map.getCenter()
    if (nextCenter) {
      setCenter(nextCenter.toJSON())
    }
  }

  const onMapClick = (e: google.maps.MapMouseEvent) => {
    mapEventChannel.emit('onMapClick', e)
  }

  const onMarkerClick = (marker: MarkerData) => {
    markerEventChannel.emit('onMarkerClick', marker)
    setSelectedMarker(marker)
  }

  return (
    <>
      <GoogleMap
        apiKey={data.GOOGLE_MAPS_API_KEY}
        markers={markers}
        onClick={onMapClick}
        onIdle={onMapIdle}
        onMarkerClick={onMarkerClick}
      />

      <Portal container={portal.current}>
        {selectedMarker && <Card {...selectedMarker} />}
      </Portal>

      <div ref={portal} />
    </>
  )
} What we did was subscribe to the events in the component and emit the events when the map and markers interacted. Moreover, By subscribing and unsubscribing with the component’s lifecycle, we are able to register only the necessary event handlers at the given moment of the user journey. Index Final Thoughts If you are looking for an Event Bus library, there are a : couple of choices recommended by Vue.js Mitt tiny-emitter There’s also an interesting . One of the maintainers suggested a few Redux-based tools to handle events: discussion on Reddit about using Redux as an Event Bus redux-toolkit’s new Listener Middleware redux-observable Redux-Saga References GitHub: Mitt GitHub: tiny-emitter GitHub: redux-observable GitHub: Redux-Saga GitHub: eventbus-demo Documentation: Vue 3 Migration Guide — Events API Documentation: redux-toolkit’s new Listener Middleware Documentation: Remix This article is originally posted on here.

Writing an Event Bus for React

70-Page Report on the COCO Dataset and Object Detection [Part 3]

Stories, News & Mentions about DATAZOO

Datazoo’s Stories on HackerNoon