Miami, December 9, 2019. Once again, the status of Miami as an international tech hub is elevated with TheVentureCity playing host to the final week of Google’s startup acceleration program, Launchpad. The event marks the end of a 10-week immersion that began in Mexico, continued in Argentina, and concludes in South Florida; connecting startups with dedicated support to take their businesses to the next level.
This week, the 9 startups in the Launchpad program will meet with startups in TheVentureCity’s own Growth program. This is an opportunity for them to share experiences, engage with each other and grow. TheVentureCity has invited top venture capitalists (VCs) from around the U.S., Europe, and Latin America as an added benefit for startups on both programs.
“Being able to host this program for startups from across Latin America in Miami feels to me like a dream come true. It is an unparalleled occasion to showcase the amazing work that developers and entrepreneurs are leading in the region", said Paco Solsona, manager of Google Developers.
For Laura González-Estéfani, CEO and founder of TheVentureCity: “This initiative consolidates Miami as an epicenter of innovation and entrepreneurship by bringing together companies that think beyond borders. We believe that talent is evenly distributed around the world, but opportunities are unequal.”
Startups on the Launchpad Accelerator come from a wide span of Latin American countries, including Argentina, México, Colombia, Chile, and El Salvador. The companies graduating this week are: 123Seguro, Al Turing, Apli, DevF, Hugo, Jetty, Jüsto, Odd Industries, and TransparentBusiness. The participating companies from TheVentureCity are: Qempo, Cajero, ComigoSaude, Digital Innovation One, TheFastMind, eMasters, Alba, 1Doc3, Stayfilm and Erudit. While being an international group, these startups represent the talent, diversity, and richness of the continent.
The main benefit of hosting this program in Miami is to diversify thinking in the American tech ecosystem and to keep relevant stakeholders informed about the challenges being faced by startups across the region. This is the second time that Google and TheVentureCity partner up to support startups; last March, we successfully hosted the first-ever Google Developers Launchpad Start, a one-week version of the accelerator program, in Miami.
About TheVentureCity
TheVentureCity is a new growth and accelerator model that helps diverse founders achieve global impact. Our mission is to make the global entrepreneurial ecosystem more diverse, international and accessible to fair capital. TheVentureCity supports founders with a global mindset to achieve their next big success.
About Google Developers Launchpad
Google Developers Launchpad is a startup accelerator program that empowers the global startup ecosystems to solve the world’s biggest challenges with the best of Google - its people, research, and advanced technologies. Started by you. Accelerated with Google.
We’re writing to you from Flutter Interact, our biggest Flutter event to date, where we’re making a number of announcements about Flutter, including a new updated release and a series of partnerships that demonstrate our commitment to supporting the ever-growing ecosystem around Flutter.
Our original release for Flutter was focused on helping you build apps that run on iOS and Android from a single codebase. But we want to go further.
We live in a world where internet-connected devices are pervading every area of our lives. Many of us transition throughout the day between multiple devices: phones, watches and other wearable devices, tablets, desktop or laptop computers, televisions and increasingly, smart displays such as the Google Nest Hub.
In this emerging world, the focus starts to move away from any individual device towards an environment where your services and software are available wherever you need them. We call this ambient computing, and it’s core to our vision for Flutter: a portable toolkit for building beautiful experiences wherever you might want to paint pixels on the screen.
With Flutter, instead of being forced to start your app development by asking “which device am I targeting?”, we want you to be able to begin by focusing on what you want to build. In this multi-device, multi-platform world, Flutter aims to provide a framework and tooling for creating user experiences without compromise on any device or form factor. The Dart-powered Flutter engine supports fast development with stateful hot reload, and fast performance in production with native compilation, whether it is running on mobile, desktop, web, or embedded devices.
If you’re a startup, Flutter lets you test your idea on your total addressable market, rather than being forced to target just one user base due to a lack of resources. If you’re a larger company, Flutter lets you consolidate your team’s resources onto shipping a single experience, reusing code across mobile, web and desktop as you see fit. Flutter is unique in supporting such a diversity of natively-compiled experiences from a single codebase.
It’s been great to see how Flutter has flourished in the short time since its initial release. Well over a million developers are already using Flutter for apps both large and small. In GitHub’s 2019 State of the Octoverse report, Dart and Flutter ranked #1 and #2 for fastest-growing language and open source project respectively over the last twelve months, and Flutter is now one of the ten most starred software repos on their site. And in a recent analysis by LinkedIn, Flutter is described as “the fastest-growing skill among software engineers”.
The rest of this article talks about our progress towards this ambient computing vision, and specifically focuses on the announcements we made today to help designers and developers collaborate together on stunning visual experiences built with Flutter.
Today at Flutter Interact, we are announcing Flutter 1.12, our latest stable release of the Flutter framework. This latest quarterly release represents the work of hundreds of contributors from inside and outside Google, and brings new performance improvements, more control over adding Flutter content to existing apps, and updates to the Material and Cupertino libraries. We also have a new Google Fonts package that provides direct access to almost 1,000 open sourced font families, putting beautiful typography within reach in just a line of code. More information about what’s new in Flutter 1.12 can be found in our dedicated blog post on the Flutter Medium channel.
Google is increasingly using Flutter for mobile app development, thanks to the productivity benefits it offers for multiplatform development. At Interact, the Stadia team showcased their app, running on both iOS and Android from the same codebase and built with Flutter. Talking about their experiences, the team had this to say:
“As Stadia was initially investigating mobile, Flutter enabled us to prototype quickly, demonstrate gameplay on Android, and then staff one team to build our cross-platform experience without compromise. We’re delighted with the results and are continuing to build new features in Flutter.”
Of course, many companies outside Google are also using Flutter for their app development. Splice provides a library of millions of sounds, loops, and presets that help musicians bring their ideas to life. When they decided to add a mobile app to supplement their existing desktop experience, they chose Flutter because, as they put it: “Speed to validate our product hypothesis was critical. We are a small team, so we needed a single solution that could deliver an equally great experience to all our users on iOS and Android.”
Within six weeks, they had built a prototype that validated their choice, and their new mobile experience is live in both the Apple Store and the Google Play Store:
Adding a mobile experience is already showing results, with a significant percentage of purchases now coming through their mobile app. And with Flutter providing consistency across multiple platforms, they’re now experimenting with bringing some of the same experiences into their desktop app.
On the subject of desktop, we’ve made much progress with macOS support. For the first time, you can use the release mode to build a fully-optimized macOS application using Flutter, and we’ve been working to expand the Material design system in Flutter to support apps that are designed for desktop-class form factors. More information on building for desktop can be found at flutter.dev/desktop.
Lastly, we’re delighted to announce the beta release of Flutter’s web support, adding stability and maturity over the previews that we shipped earlier this year. It’s now possible to build and consume web plug-ins, enabling Flutter apps to take advantage of a growing ecosystem of Dart components for everything from Firebase to the latest web APIs. Since we announced our early adopter program a couple of months ago, we’ve been working with customers like Journey to test web-based experiences with Flutter, and now we’re ready for a broader set of developers to start building web content with Flutter. More information on Flutter’s web support can be found at flutter.dev/web and at the companion blog article that was published today.
All this is possible thanks to Dart, the programming language and platform that powers Flutter across an array of ambient computing experiences. Dart is somewhat unique in offering develop-mode and release-mode toolchains for ARM, Intel, and JavaScript, enabling native compilation to almost any platform you could want to target. Today we’re releasing Dart 2.7, which adds new capabilities to the Dart language including extension methods. You can find more information about these features on the Dart blog. We’ve also released an update to DartPad that allows users to not only edit Flutter code, but also to run it and view the rendered UI.
We focused our event this year primarily on the creative technologists, prototypers, interactive designers, and visual coders. A core motivation for building Flutter was that we don’t think multi-platform development should require compromise on visual quality. We see Flutter as a canvas for creative expression and exploration, since it removes many of the restrictions that visually-oriented developers have often faced. Flutter’s stateful hot reload feature makes it easy to make changes and see the results in real-time; and with every pixel drawn by Flutter, you can blend UI, graphical content, text and video with custom animations and transformations.
In preparing for this event, we’ve been particularly inspired by the work of Robert Felker, a digital artist who has created a series of generative art explorations with Flutter that combine geometry, texture and light in stunning ways. We never envisioned Flutter being used to create images like this, but it speaks to the expressive power of Flutter, combined with artistic creativity, that the image on the right below is generated with less than 60 lines of Dart code:
Today we’re honored to be joined by several partners who are launching tools for designers to more fully participate in the creative process of building Flutter applications.
Supernova has integrated Flutter into their design and prototyping tool, with animation support, Material Design integration, and an updated interface designed for Flutter. They also announced a new browser-based tool, Supernova Cloud, which is built entirely with Flutter’s web support.
Rive (previously 2Dimensions, who published the Flare graphics tool) announced that they’re consolidating their company name and product into one brand. They unveiled their new company and product name, Rive, as well as a number of new product features. Perhaps the most notable feature in Rive is support for importing Lottie files created with Adobe After Effects, enabling deeper integration of Flutter into existing workflows for animated content. Rive now supports real-time dynamic layering effects like drop shadows, inner shadows, glows, blurs, and masking.
Rive eliminates the need to recreate designs and animations in code, greatly simplifying the designer-to-developer handoff. This means that designers are free to iterate and make changes at any time. And because it outputs real assets that integrate directly with Flutter, not just MP4 videos or GIF images, Rive allows you to create sophisticated and dynamic interactions, game characters, animated icons, and onboarding screens.
Lastly, another big endorsement of Flutter as a canvas for creatives comes from Adobe, who are announcing Flutter support in Creative Cloud with a plugin that exports designs from Adobe XD into Flutter. Adobe XD, Adobe’s user experience design platform, allows product design teams to design and prototype user experiences for mobile, web, desktop, and beyond. Instead of simply handing off design specs and leaving development teams to understand and interpret a designer’s vision, the new XD-to-Flutter plugin automatically converts XD designs into code that is immediately usable as part of your Flutter application development.
The XD to Flutter plugin will be available as open source early next year. You can find out more about XD to Flutter and sign up for early access on Adobe’s website. We’re thrilled to partner with Adobe; their pedigree in extensible design tooling will give product designers a huge head start in creating amazing Flutter experiences.
Flutter is at its heart an open source project. The value we derive for Google comes in part from the productivity gains realized by other product teams inside the company who use Flutter, but we build Flutter with you and for you, knowing that a larger ecosystem and community benefits us all. Our journey thus far has broadened from our original mobile-centric release to incorporate a wider range of form factors, and we continue to invest in designer and developer tools that increase both the productivity and the beauty of your finished application.
But what perhaps brings us the greatest satisfaction is when Flutter helps an individual turn their idea into a completed work that they can share with the world. The story in the below video of one family is a touching tribute to all those who have made Flutter possible, whether by contributing code, bug reports or fixes, or sharing knowledge with others in the community. We’re so grateful to be on this journey with you!
MediaPipe is a framework for building cross platform multimodal applied ML pipelines that consist of fast ML inference, classic computer vision, and media processing (e.g. video decoding). MediaPipe was open sourced at CVPR in June 2019 as v0.5.0. Since our first open source version, we have released various ML pipeline examples like
In this blog, we will introduce another MediaPipe example: Object Detection and Tracking. We first describe our newly released box tracking solution, then we explain how it can be connected with Object Detection to provide an Object Detection and Tracking system.
In MediaPipe v0.6.7.1, we are excited to release a box tracking solution, that has been powering real-time tracking in Motion Stills, YouTube’s privacy blur, and Google Lens for several years and that is leveraging classic computer vision approaches. Pairing tracking with ML inference results in valuable and efficient pipelines. In this blog, we pair box tracking with object detection to create an object detection and tracking pipeline. With tracking, this pipeline offers several advantages over running detection per frame:
Our general box tracking solution consumes image frames from a video or camera stream, and starting box positions with timestamps, indicating 2D regions of interest to track, and computes the tracked box positions for each frame. In this specific use case, the starting box positions come from object detection, but the starting position can also be provided manually by the user or another system. Our solution consists of three main components: a motion analysis component, a flow packager component, and a box tracking component. Each component is encapsulated as a MediaPipe calculator, and the box tracking solution as a whole is represented as a MediaPipe subgraph shown below.
MediaPipe Box Tracking Subgraph
The MotionAnalysis calculator extracts features (e.g. high-gradient corners) across the image, tracks those features over time, classifies them into foreground and background features, and estimates both local motion vectors and the global motion model. The FlowPackager calculator packs the estimated motion metadata into an efficient format. The BoxTracker calculator takes this motion metadata from the FlowPackager calculator and the position of starting boxes, and tracks the boxes over time. Using solely the motion data (without the need for the RGB frames) produced by the MotionAnalysis calculator, the BoxTracker calculator tracks individual objects or regions while discriminating from others. To track an input region, we first use the motion data corresponding to this region and employ iteratively reweighted least squares (IRLS) fitting a parametric model to the region’s weighted motion vectors. Each region has a tracking state including its prior, mean velocity, set of inlier and outlier feature IDs, and the region centroid. See the figure below for a visualization of the tracking state, with green arrows indicating motion vectors of inliers, and red arrows indicating motion vectors of outliers. Note that by only relying on feature IDs we implicitly capture the region’s appearance, since each feature’s patch intensity stays roughly constant over time. Additionally, by decomposing a region’s motion into that of the camera motion and the individual object motion, we can even track featureless regions.
Visualization of Tracking State for Each Box
An advantage of our architecture is that by separating motion analysis into a dedicated MediaPipe calculator and tracking features over the whole image, we enable great flexibility and constant computation independent of the number of regions tracked! By not having to rely on the RGB frames during tracking, our tracking solution provides the flexibility to cache the metadata across a batch of frame. Caching enables tracking of regions both backwards and forwards in time; or even sync directly to a specified timestamp for tracking with random access.
A MediaPipe example graph for object detection and tracking is shown below. It consists of 4 compute nodes: a PacketResampler calculator, an ObjectDetection subgraph released previously in the MediaPipe object detection example, an ObjectTracking subgraph that wraps around the BoxTracking subgraph discussed above, and a Renderer subgraph that draws the visualization.
MediaPipe Example Graph for Object Detection and Tracking. Boxes in purple are subgraphs.
In general, the ObjectDetection subgraph (which performs ML model inference internally) runs only upon request, e.g. at an arbitrary frame rate or triggered by specific signals. More specifically, in this example PacketResampler temporally subsamples the incoming video frames to 0.5 fps before they are passed into ObjectDetection. This frame rate can be configured differently as an option in PacketResampler.
The ObjectTracking subgraph runs in real-time on every incoming frame to track the detected objects. It expands the BoxTracking subgraph described above with additional functionality: when new detections arrive it uses IoU (Intersection over Union) to associate the current tracked objects/boxes with new detections to remove obsolete or duplicated boxes.
A sample result of this object detection and tracking example can be found below. The left image is the result of running object detection per frame. The right image is the result of running object detection and tracking. Note that the result with tracking is much more stable with less temporal jitter. It also maintains object IDs across frames.
Comparison Between Object Detection Per Frame and Object Detection and Tracking
This is our first Google Developer blog post for MediaPipe. We look forward to publishing new blog posts related to new MediaPipe ML pipeline examples and features. Please follow the MediaPipe tag on the Google Developer blog and Google Developer twitter account (@googledevs)
We have invested heavily in our API and service infrastructure to improve performance and security and to add features developers need to build world-class APIs. As we make changes we must address features that are no longer compatible with the latest architecture and business requirements.
The JSON-RPC protocol (http://www.jsonrpc.org/specification) and Global HTTP Batch (example) are two such features. Our support for these features was based on an architecture using a single shared proxy to receive requests for all APIs. As we move towards a more distributed, high performance architecture where requests go directly to the appropriate API server we can no longer support these global endpoints.
We had originally planned to decommission these features by Mar 25, 2019. However, it came to our attention that few highly impacted customers might not have received the earlier notification.
As a result, we are extending the deprecation timeline to Aug 12, 2020, when we will discontinue support for both these features. Please note the timeline extension to Aug 12, 2020 does not apply to Places API. Please visit Places SDK for iOS migration for information on Places API migration.
Starting February 2020 and running through August 2020, we will periodically inject errors for short windows of time. Please see below for exact details and schedule of planned downtime windows.
We know that these changes have customer impact and have worked to make the transition steps as clear as possible. Please see the guidance below which will help ease the transition.
To enable customers to identify systems that depend on these deprecated features, before the final turndown date is reached, there will be scheduled downtime for Global Batch and JSON-RPC starting from February 2020 and running through August 2020.
Below are details and schedule of periodic error injection windows, details of the downtime in June and July will be confirmed nearer the time, so please check back this blog post for the latest schedule.
To identify whether you use JSON-RPC, you can check whether you send requests to "https://www.googleapis.com/rpc" or "https://content.googleapis.com/rpc". If you do, you should migrate.
"https://www.googleapis.com/rpc"
"https://content.googleapis.com/rpc"
A batch request is homogenous if the inner requests are addressed to the same API, even if addressed to different methods of the same API. Homogenous batching will still be supported but through API specific batch endpoints. If you are currently forming homogeneous batch requests, using Google API Client Libraries or using non-Google API client libraries or no client library (i.e making raw HTTP requests), you should migrate.
A batch request is heterogeneous if the inner requests go to different APIs. Heterogeneous batching will not be supported after the turn down of the Global HTTP batch endpoint. If you are currently forming heterogeneous batch requests, change your client code to send only homogenous batch requests, i.e you should migrate.
Clients will need to make the changes outlined below to migrate.
If you are using JSON-RPC client libraries (either the Google published libraries or other libraries), switch to REST client libraries and modify your application to work with REST client libraries.
Example code for Javascript Before
// json-rpc request for the list method gapi.client.rpcRequest('zoo.animals.list', 'v2', {name:'giraffe'}).execute(x=>console.log(x))
// json-rest request for the list method gapi.client.zoo.animals.list({name:'giraffe'}).then(x=>console.log(x))
If you are not using client libraries (i.e. making raw HTTP requests):
Example code
// Request URL (JSON-RPC) POST https://content.googleapis.com/rpc?alt=json&key=xxx // Request Body (JSON-RPC) [{ "jsonrpc":"2.0", "id":"gapiRpc", "method":"zoo.animals.list", "apiVersion":"v2", "params":{"name":"giraffe"} }]
// Request URL (JSON-REST) GET https://content.googleapis.com/zoo/v2/animals?name=giraffe&key=xxx
If you are currently forming heterogeneous batch requests, change your client code to send only homogenous batch requests.
Example code The example demonstrates how we can split a heterogeneous batch request for 2 apis (urlshortener and zoo) into 2 homogeneous batch requests.
// heterogeneous batch request example. // Notice that the outer batch request contains inner API requests // for two different APIs. // Request to urlshortener API request1 = gapi.client.urlshortener.url.get({"shortUrl": "http://goo.gl/fbsS"}); // Request to zoo API request2 = gapi.client.zoo.animals.list(); // Request to urlshortener API request3 = gapi.client.urlshortener.url.get({"shortUrl": "https://goo.gl/XYFuPH"}); // Request to zoo API request4 = gapi.client.zoo.animal().get({"name": "giraffe"}); // Creating single heterogeneous batch request object heterogeneousBatchRequest = gapi.client.newBatch(); // adding the 4 batch requests heterogeneousBatchRequest.add(request1); heterogeneousBatchRequest.add(request2); heterogeneousBatchRequest.add(request3); heterogeneousBatchRequest.add(request4); // print the heterogeneous batch request heterogeneousBatchRequest.then(x=>console.log(x));
// Split heterogeneous batch request into two homogenous batch requests // Request to urlshortener API request1 = gapi.client.urlshortener.url.get({"shortUrl": "http://goo.gl/fbsS"}); // Request to zoo API request2 = gapi.client.zoo.animals.list(); // Request to urlshortener API request3 = gapi.client.urlshortener.url.get({"shortUrl": "http://goo.gl/fbsS"}) // Request to zoo API request4 = gapi.client.zoo.animals.list(); // Creating homogenous batch request object for urlshorterner homogenousBatchUrlshortener = gapi.client.newBatch(); // adding the 2 batch requests for urlshorterner homogenousBatchUrlshortener.add(request1); homogenousBatchUrlshortener.add(request3); // Creating homogenous batch request object for zoo homogenousBatchZoo = gapi.client.newBatch(); // adding the 2 batch requests for zoo homogenousBatchZoo.add(request2); homogenousBatchZoo.add(request4); // print the 2 homogenous batch request Promise.all([homogenousBatchUrlshortener,homogenousBatchZoo]) .then(x=>console.log(x));
If you are using Google API Client Libraries, these libraries have been regenerated to no longer make requests to the global HTTP batch endpoint. Recommendation for clients using these libraries is to upgrade to the latest version if possible. Please see the language specific guidance below for minimum Google API Client Library to upgrade to.
Update all Google API Service packages (`com.google.apis`) to a version where the supporting library version is 1.23.1 or higher. For example, upgrade `com.google.apis:google-api-services-drive` from version `v3-rev159-1.22.0` to `v3-rev20190620-1.30.1`.
com.google.api.client.googleapis.batch.BatchRequest
Drive client = Drive.builder(transport, jsonFactory, credential).setApplicationName("BatchExample/1.0").build (); BatchRequest batch = client.batch();
BatchRequest batch = client.batch();
"/batch"
"/batch/library/v1"
Rebuild
/batch/library/v1
Example code Before
HttpRequestBatch batch(service->transport());
HttpRequestBatch batch(service->transport(), service->batch_url());
Upgrade to v1.22.0 or later of the Google Cloud Java Client for Storage (released in v0.40.0 of the Google Cloud Client Library).
Upgrade to v1.9.0 or later of the GCS client.
Older versions of gcloud used global batch calls in some cases. You should update your version of gcloudl GCloud from v119.0.0 onwards is compatible with this deprecation.
In general this can be done by running "gcloud components update".
Users with pipelines written using the Beam Python SDK accessing Google Cloud Storage should update the SDK to v2.5.0 or later and rebuild their pipeline.
For help on migration, consult the API documentation or tag Stack Overflow questions with the 'google-api' tag.
Example depth map, with red indicating areas that are close by, and blue representing areas that are farther away.
A virtual cat with occlusion off and with occlusion on.
Physics, path planning, and surface interaction examples.
Summary: Flutter Interact is happening on December 11th. Sign up here for our global livestream and watch it at g.co/FlutterInteract. Google’s conference focusing on beautiful designs and apps, Flutter Interact, is streaming worldwide on December 11. Flutter Interact is a day dedicated to creation and collaboration. Whether you are a web developer, mobile developer, front-end engineer, UX designer, or designer, this is a good opportunity to hear the latest from Google. This one-day event has several talks focused on different topics regarding development and design. Speakers include Matias Duarte, VP of Google Design; Tim Sneath, Group PM for Flutter and Dart; and Grant Skinner, CEO, GSkinner, Inc.
It will include content and announcements from the Material Design and Flutter teams, partners, and other companies.
We are grateful to experience Flutter Interact with you on December 11th. In the meantime, follow us on twitter at @FlutterDev and get started with Flutter at flutter.dev.
Last month, we announced that Coral graduated out of beta, into a wider, global release. Today, we're announcing the next version of Mendel Linux (4.0 release Day) for the Coral Dev Board and SoM, as well as a number of other exciting updates.
We have made significant updates to improve performance and stability. Mendel Linux 4.0 release Day is based on Debian 10 Buster and includes upgraded GStreamer pipelines and support for Python 3.7, OpenCV, and OpenCL. The Linux kernel has also been updated to version 4.14 and U-Boot to version 2017.03.3.
We’ve also made it possible to use the Dev Board's GPU to convert YUV to RGB pixel data at up to 130 frames per second on 1080p resolution, which is one to two orders of magnitude faster than on Mendel Linux 3.0 release Chef. These changes make it possible to run inferences with YUV-producing sources such as cameras and hardware video decoders.
To upgrade your Dev Board or SoM, follow our guide to flash a new system image.
MediaPipe is an open-source, cross-platform framework for building multi-modal machine learning perception pipelines that can process streaming data like video and audio. For example, you can use MediaPipe to run on-device machine learning models and process video from a camera to detect, track and visualize hand landmarks in real-time.
Developers and researchers can prototype their real-time perception use cases starting with the creation of the MediaPipe graph on desktop. Then they can quickly convert and deploy that same graph to the Coral Dev Board, where the quantized TensorFlow Lite model will be accelerated by the Edge TPU.
As part of this first release, MediaPipe is making available new experimental samples for both object and face detection, with support for the Coral Dev Board and SoM. The source code and instructions for compiling and running each sample are available on GitHub and on the MediaPipe documentation site.
A new Teachable Sorter tutorial is now available. The Teachable Sorter is a physical sorting machine that combines the Coral USB Accelerator's ability to perform very low latency inference with an ML model that can be trained to rapidly recognize and sort different objects as they fall through the air. It leverages Google’s new Teachable Machine 2.0, a web application that makes it easy for anyone to quickly train a model in a fun, hands-on way.
The tutorial walks through how to build the free-fall sorter, which separates marshmallows from cereal and can be trained using Teachable Machine.
Earlier this month, the TensorFlow team announced a new version of TensorFlow Hub, a central repository of pre-trained models. With this update, the interface has been improved with a fresh landing page and search experience. Pre-trained Coral models compiled for the Edge TPU continue to be available on our Coral site, but a select few are also now available from the TensorFlow Hub. On the site, you can find models featuring an Overlay interface, allowing you to test the model's performance against a custom set of images right from the browser. Check out the experience for MobileNet v1 and MobileNet v2.
We are excited to share all that Coral has to offer as we continue to evolve our platform. For a list of worldwide distributors, system integrators and partners, visit the new Coral partnerships page. We hope you’ll use the new features offered on Coral.ai as a resource and encourage you to keep sending us feedback at coral-support@google.com.
High Level Details
Date: All entries must be submitted by January 20, 2020 11:59 PM PST (GMT-8).
How to Submit: Entries will be collected on the form linked at flutter.dev/clock, but see the Official Rules for full details.
Winners: Submissions will be rated by Google and Flutter expert judges against the following rubric: visual beauty, code quality, novelty of idea, and overall execution.
Prizes: Potential prizes include a fully loaded iMac Pro, Lenovo Smart Display, and Lenovo Smart Clock. Also, all complete and valid submissions will receive a digital certificate of completion. In addition, some of the clock contest submissions might be integrated into the Lenovo Smart Clock's lineup of clock faces, or used as inspiration for future clock faces!
Results will be announced at our Mobile World Congress 2020 Keynote.
Good luck and have fun! Time is ticking…
Japan is well known as an epicenter of innovation and technology, and its startup ecosystem is no different. We’ve seen this first hand from our work with startups such as Cinnamon-- who uses artificial intelligence to remove repetitive tasks from office workers daily function, allowing more work to get done by fewer people, faster.
This is why we are pleased to announce our second accelerator program, housed at the new Google for Startups Campus in the heart of Tokyo. The Google for Startups Accelerator (previously Launchpad Accelerator) is an intensive three-month program for high potential, AI-focused startups, utilizing the proven Launchpad foundational components and content.
Founders who successfully apply for the accelerator will have the opportunity to work on the technical problems facing their startup alongside relevant experts from Google and the industry. They will receive mentorship on these challenges, support on machine learning best practices, as well as connections to relevant teams from across Google to help grow their business.
In addition to mentorship and technical project support, the accelerator also includes deep dives and workshops focused on product design, customer acquisition, and leadership development for founders.
“We hope that by providing these founders with the tools, mentorship, and connections to prepare for the next step in their journey it will, in turn, contribute to a stronger Japanese economy.” says Takuo Suzuki, Google Developers Regional Lead for Japan. “We are excited to work with such passionate startups in a new Google for Startups Campus, an environment built to foster startup growth, and meet our next cohort in 2020”
The program will run from February-May 2020 and applications are now open until 13th December 2019.
