Take a better selfie with Lily

Selfie sticks were the must have Xmas gift last year and now a team out of the UC Berkeley robotics lab, who built the first prototype using a Raspberry Pi and an Arduino, have developed the Lily camera drone. Watch the video below to see how it works but basically it flies itself and can take video or stills of its owner. Its on my Christmas list.



from The Universal Machine http://universal-machine.blogspot.com/

Put the internet to work for you.

Delete or edit this Recipe

Recommended for you

Read More..

Calculating Ada The Countess of Computing

With Ada Lovelace Day fast approaching (Oct 13) the BBC has released a timely documentary all about her called "Calculating Ada: The Countess of Computing". This is the first documentary Ive seen dedicated to Ada Lovelace and I learnt a lot. For instance I didnt know that she lost a fortune gambling on horse racing. She believed she could calculate the odds better than the bookmakers - she was wrong. The doco is available on YouTube, though I expect it will be taken down soon; otherwise it can be viewed on the BBc iPlayer.


from The Universal Machine http://universal-machine.blogspot.com/

Put the internet to work for you.

Turn off or edit this Recipe

Recommended for you

Read More..

Creating a templated Binary Search Tree Class in C

Creating a basic template Tree Class in C++

(Works in Linux and Windows)

If you just want the code and not the walkthrough, it is attached at the end (I use the GNU GPL license, so do whatever you want with the code as long as you mention me).

There a multiple benefits of creating a Tree class based on a template. With a template, the tree can be a container for anything while still being fairly clean code. We will also create this class to be easily inherited for other trees such as an AVL and Huffman tree (which we will implement later).

A tree is a widely used data structure which organizes a set of nodes containing data. More can be found on it here: http://en.wikipedia.org/wiki/Tree_%28data_structure%29

This tree will be a Binary Search Tree; however, it will be easily inheritable so that other trees (Binary trees, such as AVL and Red-Black) can be defined based on it.

First we will set up our Node as a holder for the data and tree information such as the parent and connected nodes (the leaves). I overload the < operator so that we can search and sort this tree using the c++ algorithm include if we so desire.

template <class T>
class Node {
public:
    T data;
    Node *left, *right, *parent;

    Node() {
        left = right = parent = NULL;
    };
    Node(T &value) {
        data = value;
    };
    ~Node() {
    };   
    void operator= (const Node<T> &other) {
        data = other.data;
    };
    bool operator< (T &other) {
        return (data < other);
    };
};

Our tree will basically just be a bunch of these Nodes pointing to each other, with some functions to manage the data structure.

template <class T>
class Tree {
public:
    Tree() {
        root = NULL;
    };

    ~Tree() {
        m_destroy(root);
    };

    //We will define these all as virtuals for inherited trees (like a Huffman Tree and AVL Tree shown later)
    virtual void insert(T &value) {
        m_insert(root,NULL,value);
    };
    virtual Node<T>* search(T &value) {
        return m_search(root,value);
    };
    virtual bool remove(T &value) {
        return m_remove(root,value);
    };
    virtual bool operator< (Tree<T> &other) {
        return (root->data < other.first()->data);
    };
    void operator= (Tree<T> &other) {
        m_equal(root,other.first());
    };
    Node<T>*& first() {
        return root;
    };


protected:
    //this will be our root node and private functions
    Node<T> *root;
    void m_equal(Node<T>*& node, Node<T>* value) {
        if(value != NULL) {
            node = new Node<T>();
            *node = *value;
            if(value->left != NULL)
                m_equal(node->left, value->left);
            if(value->right != NULL)
                m_equal(node->right, value->right);
        }
    }

    void m_destroy(Node<T>* value) {
        if(value != NULL) {
            m_destroy(value->left);
            m_destroy(value->right);
            delete value;
        }
    };
    void m_insert(Node<T> *&node, Node<T> *parent, T &value) {
        if(node == NULL) {
            node = new Node<T>();
            *node = value;
            node->parent = parent;
        } else if(value < node->data) {
            m_insert(node->left,node,value);
        } else
            m_insert(node->right,node,value);
    };
    void m_insert(Node<T> *&node, Node<T> *parent, Tree<T> &tree) {
        Node<T> *value = tree.first();
        if(node == NULL) {
            node = new Node<T>();
            *node = *value;
            node->parent = parent;
        } else if(value->data < node->data) {
            m_insert(node->left,tree);
        } else
            m_insert(node->right,tree);
    };
    Node<T>* m_search(Node<T> *node, T &value) {
        if(node == NULL)
            return NULL;
        else if(value == node->data)
            return node;
        else if(value < node->data)
            return m_search(node->left,value);
        else
            return m_search(node->right,value);
    };

    bool m_remove(Node<T> *node, T &value) {
        //messy, need to speed this up later
        Node<T> *tmp = m_search(root,value);
        if(tmp == NULL)
            return false;
        Node<T> *parent = tmp->parent;
        //am i the left or right of the parent?
        bool iamleft = false;
        if(parent->left == tmp)
            iamleft = true;
        if(tmp->left != NULL && tmp->right != NULL) {
            if(parent->left == NULL || parent->right == NULL) {
                parent->left = tmp->left;
                parent->right = tmp->right;
            } else {
                if(iamleft)
                    parent->left = tmp->left;
                else
                    parent->right = tmp->left;
                T data = tmp->right->data;
                delete tmp;
                m_insert(root,NULL,data);
            }
        } else if(tmp->left != NULL) {
            if(iamleft)
                parent->left = tmp->left;
            else
                parent->right = tmp->left;
        } else if(tmp->right != NULL ) {
            if(iamleft)
                parent->left = tmp->right;
            else
                parent->right = tmp->right;
        } else {
            if(iamleft)
                parent->left = NULL;
            else
                parent->right = NULL;
        }
        return true;
    };
};

And thats all we need for a basic binary search tree. The full code is shown below

Tree.h 

Consider donating to further my tinkering.

Places you can find me

• Facebook
• Google+
• Linkedin
• Blogspot
• Google-Code
• Github
• YouTube
• Twitter

Read More..

Projecting without a projector sharing your smartphone content onto an arbitrary display

Posted by Yang Li, Research Scientist, Google Research

Previously, we presented Deep Shot, a system that allows a user to “capture” an application (such as Google Maps) running on a remote computer monitor via a smartphone camera and bring the application on the go. Today, we’d like to discuss how we support the opposite process, i.e., transferring mobile content to a remote display, again using the smartphone camera.

Although the computing power of today’s mobile devices grows at an accelerated rate, the form factor of these devices remains small, which constrains both the input and output bandwidth for mobile interaction. To address this issue, we investigated how to enable users to leverage nearby IO resources to operate their mobile devices. As part of the effort, we developed Open Project, an end-to-end framework that allows a user to “project” a native mobile application onto an arbitrary display using a smartphone camera, leveraging interaction spaces and input modality of the display. The display can range from a PC or laptop monitor, to a home Internet TV and to a public wall-sized display. Via an intuitive, projection-based metaphor, a user can easily share a mobile application by projecting it onto a target display.

Open Project is an open, scalable, web-based framework for enabling mobile sharing and collaboration. It can turn any computer display projectable instantaneously and without deployment. Developers can add support for Open Project in native mobile apps by simply linking a library, requiring no additional hardware or sensors. Our user participants responded highly positively to Open Project-enabled applications for mobile sharing and collaboration.

Read More..

Will a robot take your job

With robotic technology advancing at a pace there is the obvious prospect that robots will start to perform a wider range of services and tasks and not be limited to factory manufacturing as they are at the moment. A recent article in Wired called "Robots Will Steal Our Jobs, But They Will Give Us New Ones" makes the argument that although many current jobs will be taken by robots new opportunities will arise - the most obvious of which is servicing and maintaining all the robots. Incidentally the photo here is of a robot that can cook a hamburger and the Japanese have robots that can prepare Ramen noodles.

from The Universal Machine http://universal-machine.blogspot.com/

Put the internet to work for you.

Delete or edit this Recipe

Recommended for you

Read More..

Hacker Tricks from Insiders A Threat to ERP Systems

Today, with the extensive use of ERP systems world wide, there has also been a flanking growth in security related issues. And although ERP security plans aim at keeping outside intruders from gaining entry to a system’s inner network, the problem gets even bigger when hackers get illegal access to the information on ERP transactions, and when they spread Malware such as worms, spyware and viruses.

One of the main ERP business issues in our internet age is the increase in the number of these so called hackers, with some of them even hosting their own virus-filled websites. While some of them do this for financial gains, others just do it for fun. Largely, security in ERP requires a fresh approach; one that not just focuses on data but also on the security of the transactions involved.

While threats from outsider intrusions and attacks continue to go up, the chances for insider systems misuse has also grown by a long way. The fact is that, at the level of transaction, security flaws can be used more often than not by people inside the system. Although many of the available ERP systems present data encryption features which restrict people from exporting any files, it doesn’t satisfy the need for security from fraudulent insiders who take advantage of the authorization they have.

Though ERP systems have used audit logs for keeping an eye on the transactions made by an insider, or any updates in the system; these don’t give much information on whether the transaction was actually necessary or appropriate. And even though suspicious transactions can be sorted out by internal auditors; many organizations don’t install the audit log feature for their ERP system, as some believe that it may affect the performance of the employees.

What’s more, ERP applications continue to be susceptible to security attacks from outsiders as well, as anyone can now break feeble passwords with plain dictionary attacks. On the other hand, some of the most destructive hacker tricks arrive with the use of social engineering, which is about fooling people into giving out their identification details. Meanwhile, many companies have cut down on security related measures that focus on insiders, as they feel that it may act like an added overhead for their employees, and as it appears to affect their efficiency in carrying out their work.

Overall, the threat from insiders seems like the one that causes most of the security issues in organizations these days. And it does look like the future of ERP security would be all about identifying improper use of the system by users inside the organization. After recognizing the significant shortage in ERP security for protecting from insider threats, leading businesses are now using methods that continuously monitor transactions made by authorized users. These work by identifying suspicious transactions and checking whether it is linked to any fraudulent activity. So, if any employee appears to be doing some hacking-like activity, he or she can be instantly contacted though voip and questioned about the reason for such a transaction

Read More..

Forget Turing the Lovelace Test Has a Better Shot at Spotting AI

I recently blogged about a chatbot, called Eugene Goostman, that was claimed to have passed Alan Turings famous measure of machine intelligence in June by posing as a Ukrainian teenager with questionable language skills. Motherboard notices that "the world went nuts for about an hour before realizing that the bot, far from having achieved human-level intelligence, was actually pretty dumb." This article proposes the Lovelace test for AI that demands an act of creativity from an AI rather than automated conversational skills - its an interesting idea and would be a good way of honouring Ada Lovelace.

from The Universal Machine http://universal-machine.blogspot.com/

Put the internet to work for you.

Turn off or edit this Recipe

Recommended for you

Read More..

A Billion Words Because todays language modeling standard should be higher

Posted by Dave Orr, Product Manager, and Ciprian Chelba, Research Scientist

Language is chock full of ambiguity, and it can turn up in surprising places. Many words are hard to tell apart without context: most Americans pronounce “ladder” and “latter” identically, for instance. Keyboard inputs on mobile devices have a similar problem, especially for IME keyboards. For example, the input patterns for “Yankees” and “takes” look very similar:

Photo credit: Kurt Partridge

But in this context -- the previous two words, “New York” -- “Yankees” is much more likely.

One key way computers use context is with language models. These are used for predictive keyboards, but also speech recognition, machine translation, spelling correction, query suggestions, and so on. Often those are specialized: word order for queries versus web pages can be very different. Either way, having an accurate language model with wide coverage drives the quality of all these applications.

Due to interactions between components, one thing that can be tricky when evaluating the quality of such complex systems is error attribution. Good engineering practice is to evaluate the quality of each module separately, including the language model. We believe that the field could benefit from a large, standard set with benchmarks for easy comparison and experiments with new modeling techniques.

To that end, we are releasing scripts that convert a set of public data into a language model consisting of over a billion words, with standardized training and test splits, described in an arXiv paper. Along with the scripts, we’re releasing the processed data in one convenient location, along with the training and test data. This will make it much easier for the research community to quickly reproduce results, and we hope will speed up progress on these tasks.

The benchmark scripts and data are freely available, and can be found here: http://www.statmt.org/lm-benchmark/

The field needs a new and better standard benchmark. Currently, researchers report from a set of their choice, and results are very hard to reproduce because of a lack of a standard in preprocessing. We hope that this will solve both those problems, and become the standard benchmark for language modeling experiments. As more researchers use the new benchmark, comparisons will be easier and more accurate, and progress will be faster.

For all the researchers out there, try out this model, run your experiments, and let us know how it goes -- or publish, and we’ll enjoy finding your results at conferences and in journals.

Read More..

Apple is building a car

The Guardian revealed last week that Apple is looking for a secure vehicle test track facility near SiliconValley. Therefore confirming the rumours that Apple is working on building a self-driving car. However, an article in The Verge warns Apple fans not to hold their breath. The development cycl e time from concept to production, for established car manufacturers, is in excess of 5 years. Apple has no experience in this market and consequently may be expected to take longer. Of course this may be like Apple Maps where Apple belatedly realised they strategically couldnt gift location support to Google and their established mapping product. Google, of course, has been developing driverless cars for ages. Apple has perhaps realised it cant leave this market segment to Google or risk just partnering with one car manufacturer.

from The Universal Machine http://universal-machine.blogspot.com/

Put the internet to work for you.

Delete or edit this Recipe

Recommended for you

Read More..

A step closer to quantum computation with Quantum Error Correction

Posted by Julian Kelly, Rami Barends, and Austin Fowler, Quantum Electronics Engineers

Computer scientists have dreamt of large-scale quantum computation since at least 1994 -- the hope is that quantum computers will be able to process certain calculations much more quickly than any classical computer, helping to solve problems ranging from complicated physics or chemistry simulations to solving optimization problems to accelerating machine learning tasks.

One of the primary challenges is that quantum memory elements (“qubits”) have always been too prone to errors. They’re fragile and easily disturbed -- any fluctuation or noise from their environment can introduce memory errors, rendering the computations useless. As it turns out, getting even just a small number of qubits together to repeatedly perform the required quantum logic operations and still be nearly error-free is just plain hard. But our team has been developing the quantum logic operations and qubit architectures to do just that.

In our paper “State preservation by repetitive error detection in a superconducting quantum circuit”, published in the journal Nature, we describe a superconducting quantum circuit with nine qubits where, for the first time, the qubits are able to detect and effectively protect each other from bit errors. This quantum error correction (QEC) can overcome memory errors by applying a carefully choreographed series of logic operations on the qubits to detect where errors have occurred.

Photograph of the device containing nine quantum bits (qubits). Each qubit interacts with its neighbors to protect them from error.

So how does QEC work? In a classical computer, we can monitor bits directly to detect errors. However, qubits are much more fickle -- measuring a qubit directly will collapse entanglement and superposition states, removing the quantum elements that make it useful for computation.

To get around this, we introduce additional ‘measurement’ qubits, and perform a series of quantum logic operations that look at the measurement and data qubits in combination. By looking at the state of these pairwise combinations (using quantum XOR gates), and performing some careful cross-checking, we can pull out just enough information to detect errors without altering the information in any individual qubit.

The basics of error correction. ‘Measurement’ qubits can detect errors on ‘data’ qubits through the use of quantum XOR gates.

We’ve also shown that storing information in five qubits works better than just storing it in one, and that with nine qubits the error correction works even better. That’s a key result -- it shows that the quantum logic operations are trustworthy enough that by adding more qubits, we can detect more complex errors that otherwise may cause algorithmic failure.

While the basic physical processes behind quantum error correction are feasible, many challenges remain, such as improving the logic operations behind error correction and testing protection from phase-flip errors. We’re excited to tackle these challenges on the way towards making real computations possible.

Read More..

Could you fly a fighter jet with your mind

Jan Sheuermann can and she is quadriplegic, owing to a neurodegenerative disease. As part of Darpas Revolutionizing Prosthetics research track Jan was first trained to control a robotic arm with her mind alone and has recently been flying a F-35 Joint Strike Fighter (the US militarys next-generation attack jet) using a flight simulator. You can read more about this in a Wired article theres also a video.

from The Universal Machine http://universal-machine.blogspot.com/

Put the internet to work for you.

Delete or edit this Recipe

Recommended for you

Read More..

Mounting the home directory on a different drive on the Raspberry Pi

I found myself struggling with SD card corruption this week.
I think it was due to a combination of overclocking and an old SD card. Although I use svn or git with most of my code, occasionally I do a lot of work in a day and forget to add a file. After this last time, I decided to move my home directory to a partition on an external HDD just in case.

I will be posting some file recovery methods later in case you have also lost data.

Start by making sure your external drive is connected and open a terminal.

First of all you need to have root privileges to do all this (or use sudo privileges)

Make sure your drive is not mounted. To unmount it:

umount /mntpoint
If you already have your external drive partitioned, skip to Step 4.

Step 1: Partition External Drive

The fdisk command with the -l flag can list all of your drives and partitions. So start by running that:

fdisk -l

Pick the HDD you want to use (mine was /dev/sdb but Ill put sdx and you can fill in appropriately) and run fdisk again to see partition information

fdisk /dev/sdx

You should be in an interactive prompt. Type p to see the partitions. There should be none. If there arent any, skip to Step 3.

Step 2: Deleting or resizing

If you need the old partitions and want to shrink them, type q to exit the fdisk prompt, otherwise skip to Step  3.

If you are using the partitions and just want to resize them, then there are various commands to do that (also its a good idea to have a back up).

For ext3/ext4, just use: resize2fs /dev/sdx #size

Or use parted

parted /dev/sdx (opens interactive prompt)

resize #size

For ntfs: 

ntfsresize --size #sizeM /dev/sdx

Then open back up the fdisk prompt, you need to make new partitions that match.

Step 3: Writing partition changes

(Open fdisk back open if you closed it)

Now just use d #partition to delete any old partitions.

Then type n to make a new partition followed by p to make it a primary partition. If this is the only partition you need, you can make it the whole disk size. If you shrank a partition, you need to make two new partitions, with the first one having a size that matches your resize options.

Now type w to write changes to disk then q to quit. It will probably give you some warnings, it almost always does. Pay attention to them but dont freak out.

Now format the new partition (If you only made one partition #=1):

mkfs.ext4 /dev/sdx#

Step 4: Copying over your home directory files

Mount your new partition:

sudo mkdir /media/tmp

sudo mount -t ext4 /media/tmp

Navigate to your root folder

cd /home

Copy all your data recursively (this option seems to have worked the best for me to get all of the files including .bashrc and .vimrc files)

sudo cp -rp ./ /media/tmp

Step 5: Mounting your new home directory

Once that is finished, you can move the home directory and mount the new one (make sure no program is currently using the home directory or you will get errors).

sudo umount /media/tmp

sudo rm -rf /media/tmp (get rid of the tmp folder)

sudo mv /home /old_home

sudo mkdir /home

sudo echo "/dev/sdx# /home ext4 defaults,noatime,nodiratime 0 0" >> /etc/fstab

Again replacing x# with your drive number (mine was b2).

Now we can test it by mounting home. If this doesnt work, somewhere you messed up

sudo mount /home

After you have confirmed everything is working and copied over and you dont need your old home directory, you can delete it.

sudo rm -fr /old_home

Now you dont need to worry about SD Corruption.

References for help:

http://joshua14.homelinux.org/blog/?p=660

http://linuxtechres.blogspot.com/2007/08/how-to-use-ntfsresize-from-command-line.html

Consider donating to further my tinkering.

Places you can find me

• Facebook
• Google+
• Linkedin
• Blogspot
• Google-Code
• Github
• YouTube
• Twitter

Read More..

How Google Translate squeezes deep learning onto a phone

Posted by Otavio Good, Software Engineer, Google Translate

Today we announced that the Google Translate app now does real-time visual translation of 20 more languages. So the next time you’re in Prague and can’t read a menu, we’ve got your back. But how are we able to recognize these new languages?

In short: deep neural nets. When the Word Lens team joined Google, we were excited for the opportunity to work with some of the leading researchers in deep learning. Neural nets have gotten a lot of attention in the last few years because they’ve set all kinds of records in image recognition. Five years ago, if you gave a computer an image of a cat or a dog, it had trouble telling which was which. Thanks to convolutional neural networks, not only can computers tell the difference between cats and dogs, they can even recognize different breeds of dogs. Yes, they’re good for more than just trippy art—if youre translating a foreign menu or sign with the latest version of Googles Translate app, youre now using a deep neural net. And the amazing part is it can all work on your phone, without an Internet connection. Here’s how.

Step by step

First, when a camera image comes in, the Google Translate app has to find the letters in the picture. It needs to weed out background objects like trees or cars, and pick up on the words we want translated. It looks at blobs of pixels that have similar color to each other that are also near other similar blobs of pixels. Those are possibly letters, and if they’re near each other, that makes a continuous line we should read.

Second, Translate has to recognize what each letter actually is. This is where deep learning comes in. We use a convolutional neural network, training it on letters and non-letters so it can learn what different letters look like.

But interestingly, if we train just on very “clean”-looking letters, we risk not understanding what real-life letters look like. Letters out in the real world are marred by reflections, dirt, smudges, and all kinds of weirdness. So we built our letter generator to create all kinds of fake “dirt” to convincingly mimic the noisiness of the real world—fake reflections, fake smudges, fake weirdness all around.

Why not just train on real-life photos of letters? Well, it’s tough to find enough examples in all the languages we need, and it’s harder to maintain the fine control over what examples we use when we’re aiming to train a really efficient, compact neural network. So it’s more effective to simulate the dirt.

Some of the “dirty” letters we use for training. Dirt, highlights, and rotation, but not too much because we don’t want to confuse our neural net.

The third step is to take those recognized letters, and look them up in a dictionary to get translations. Since every previous step could have failed in some way, the dictionary lookup needs to be approximate. That way, if we read an ‘S’ as a ‘5’, we’ll still be able to find the word ‘5uper’.

Finally, we render the translation on top of the original words in the same style as the original. We can do this because we’ve already found and read the letters in the image, so we know exactly where they are. We can look at the colors surrounding the letters and use that to erase the original letters. And then we can draw the translation on top using the original foreground color.

Crunching it down for mobile

Now, if we could do this visual translation in our data centers, it wouldn’t be too hard. But a lot of our users, especially those getting online for the very first time, have slow or intermittent network connections and smartphones starved for computing power. These low-end phones can be about 50 times slower than a good laptop—and a good laptop is already much slower than the data centers that typically run our image recognition systems. So how do we get visual translation on these phones, with no connection to the cloud, translating in real-time as the camera moves around?

We needed to develop a very small neural net, and put severe limits on how much we tried to teach it—in essence, put an upper bound on the density of information it handles. The challenge here was in creating the most effective training data. Since we’re generating our own training data, we put a lot of effort into including just the right data and nothing more. For instance, we want to be able to recognize a letter with a small amount of rotation, but not too much. If we overdo the rotation, the neural network will use too much of its information density on unimportant things. So we put effort into making tools that would give us a fast iteration time and good visualizations. Inside of a few minutes, we can change the algorithms for generating training data, generate it, retrain, and visualize. From there we can look at what kind of letters are failing and why. At one point, we were warping our training data too much, and ‘$’ started to be recognized as ‘S’. We were able to quickly identify that and adjust the warping parameters to fix the problem. It was like trying to paint a picture of letters that you’d see in real life with all their imperfections painted just perfectly.

To achieve real-time, we also heavily optimized and hand-tuned the math operations. That meant using the mobile processor’s SIMD instructions and tuning things like matrix multiplies to fit processing into all levels of cache memory.

In the end, we were able to get our networks to give us significantly better results while running about as fast as our old system—great for translating what you see around you on the fly. Sometimes new technology can seem very abstract, and its not always obvious what the applications for things like convolutional neural nets could be. We think breaking down language barriers is one great use.

Read More..

The Plan to Build a Massive Online Brain for All the World’s Robots

This is a clever idea (in fact I thought of it a few years ago as well). Now with excellent WiFi and 4G connectivity there is no need for an individual robot to carry all its processing power onboard. Instead they can delegate some decisions to the cloud. Wired recently reported on a project to do just this - to build a massive robot brain in the c loud. Indeed I believe that Googles driverless cars can also use the cloud to aid their decision making. I cant find a link for this so would be grateful if a reader who knows a relevant URl could comment.

from The Universal Machine http://universal-machine.blogspot.com/

Put the internet to work for you.

Turn off or edit this Recipe

Recommended for you

Read More..

A Beginner’s Guide to Deep Neural Networks

Posted by Natalie Hammel and Lorraine Yurshansky, creators of Nat & Lo’s 20% Project

Last year, we (a couple of people who knew nothing about how voice search works) set out to make a video about the research that’s gone into teaching computers to recognize speech and understand language.

Making the video was eye-opening and brain-opening. It introduced us to concepts we’d never heard of – like machine learning and artificial neural networks – and ever since, we’ve been kind of fascinated by them. Machine learning, in particular, is a very active area of Computer Science research, with far-ranging applications beyond voice search – like machine translation, image recognition and description, and Google Voice transcription.

So... still curious to know more (and having just started this project) we found Google researchers Greg Corrado and Christopher Olah and ambushed them with our machine learning questions.

This video is our attempt to distill what we learned from talking with them, but if anything in it piques your curiosity, or you have other questions, you’re in luck! On Friday, September 25, at 1 PM PDT / 4 PM EST Greg and Chris will be doing an Ask Me Anything on Reddit (see the calendar here) to answer your deep learning questions.

Everyone who’s curious is welcome to join, ask questions, and hopefully gain a better understanding of the world of machine learning and deep neural networks. (And we’ll be hanging out with them, too...in case you have any questions about video making or dogs.) We hope to see you this Friday!

Read More..

How to Copy or Hide a File inside an Image

Have a secret file and want to hide it on your system from other users? Here is a simple but cool trick that will enable you to hide a file in an image. The trick is so cool that you won’t be able to find out if the image is hiding a file behind it or not.

The jpeg image will not only look like usual image file but also work like one. The image will not only hide the document but also open in the Picture Viewer as usual. Great isn’t it?

Steps to hide files behind an Image:

1. Create a new folder (I created in drive C: named “a”).
2. Place all the documents/files in it that you want to hide (I stored z.txt in it).
3. Copy any image of yours in it (I stored x.jpg in it).
4. Make a rar archive of all the files that you need to hide (I created one named z.rar).
5. Now open cmd (Start->Run->cmd)
6. Go to the folder’s location by typing cd location like for me it was cd C:a
7. Now just type the following command with name that corresponds to your file

copy /b x.jpg + z.rar x.jpg

The screen will look like as shown above.

Steps to see/recover file back:

Just rename the final image to rar that is x.jpg to x.rar

The archive will be having your file

Read More..

The life of a software engineer

As programmers well all recognise this feeling. How many times have you felt like this? This cartoon was posted in the blog on http://programming.com/.

from The Universal Machine http://universal-machine.blogspot.com/

Put the internet to work for you.

Turn off or edit this Recipe

Recommended for you

Read More..

A Farewell to Orkut

Youve probably never heard of Orkut (unless youre Brazilian) and I didnt even recall having an account with them, but yesterday I received an email from Google telling me they were closing the service down. Orkut was Googles version of Facebook; launched in 2004 it became one of India and Brazils most popular websites. However, Facebook e clipsed it in the rest of the Western World and if you live in the West (outside of Brazil) then youve probably never heard of it. Google say that the growth in YouTube and Google+ means that Orkut is no longer needed. It lasted longer than Google Buzz though, which barely lasted a year.

from The Universal Machine http://universal-machine.blogspot.com/

Put the internet to work for you.

Turn off or edit this Recipe

Recommended for you

Read More..

A Project on Windows NT

Some of the important points are listed below:

• Boot Loader Phase
• Kernel loading phase
• Session Manager
• Winlogon
• Releases
• Major features
• Architecture of Windows NT
• Hardware requirements

This article is shared by one of the reader: SAHADEV KADLAG
Download the file here:

• WINDOWS_NateWare.zip - The pptx file
• windows_NToriginal&final.zip - A Documentation on the project

Read More..

Building A Visual Planetary Time Machine

Posted by Randy Sargent, Google/Carnegie Mellon University; Matt Hancher and Eric Nguyen, Google; and Illah Nourbakhsh, Carnegie Mellon University

When a societal or scientific issue is highly contested, visual evidence can cut to the core of the debate in a way that words alone cannot — communicating complicated ideas that can be understood by experts and non-experts alike. After all, it took the invention of the optical telescope to overturn the idea that the heavens revolved around the earth.

Last month, Google announced a zoomable and explorable time-lapse view of our planet. This time-lapse Earth enables you explore the last 29 years of our planet’s history — from the global scale to the local scale, all across the planet. We hope this new visual dataset will ground debates, encourage discovery, and shift perspectives about some of today’s pressing global issues.

This project is a collaboration between Google’s Earth Engine team, Carnegie Mellon University’s CREATE Lab, and TIME Magazine — using nearly a petabyte of historical record from USGS’s and NASA’s Landsat satellites. And in this post, we’d like to give a little insight into the process required to build this time-lapse view of our planet.

Previews of the phenomena visible in these time-lapses.

First well describe Google’s Earth Engine system for deriving the time-series imagery. Second, well tell you more about CMU’s open-source “Time Machine” software for creating and streaming large, explorable time-series imagery.

Annual Composites: Distilling a Massive Dataset

Google Earth Engine brings together the worlds scientific satellite imagery — over a petabyte of multispectral imagery recording over 40 years of history — and makes it available online with tools that scientists, independent researchers, and nations can use to mine this massive warehouse of data to detect changes, map trends and quantify differences on the Earths surface using Google’s computational infrastructure. Today, the platform is used to monitor the Amazon and estimate forest carbon in Tanzania, among hundreds of other partners developing new uses for the technology.

Using Earth Engine, we first built annual global mosaics at a resolution of 30 meters per pixel for each year from 1984 through 2012. We started with a total of 2,068,467 scenes from the Landsat 4, 5, and 7 satellites, comprising 909 terabytes of data. The Earth’s atmosphere is a constantly-shifting sea of clouds, so in order to assemble a seamless cloud-free view of each year we analyzed all the images available at each location and used a simple cloud model to separate out the clouds from the ground. To help correct for atmospheric and seasonal effects, we used an additional 20TB of data from the MODIS MCD43A4 product to build a cloud-free low-resolution model of the Earth over time. We combined all this to produce a statistical estimate of the color of each pixel for every year for which data was available. Producing the final 29 global mosaics took a bit less than a day and consumed approximately 260,000 core-hours of CPU.

Some areas of the planet are almost perpetually cloudy, obscuring satellite views. In addition, before the more capable Landsat 7 began operating in 1999, coverage in some areas of the world was sparse, particularly in Asia, for various operational and technological reasons. We wrestled with how best to visualize areas with missing or cloud-obscured images from each year. In the end, after much experimentation, we chose to simply interpolate between valid image years. Other techniques, such as greying out invalid data, created distractingly large artifacts, visually drowning out the valid information. However, the downside with the approach we have taken is that it can be difficult to tell which data is original and which is interpolated. We are exploring the possibility of including a view that allows drilling down into the non-interpolated, original mosaics.

"Time Machine": An HTML5 Time-Series Exploration Tool

Once we had produced the final global images, we adapted the Carnegie Mellon CREATE Lab’s open-source “Time Machine” software, which enables authoring, streaming, and exploring very-high-resolution videos. Time Machine videos take advantage of the power of HTML5 and modern web browsers: they are streamed as multiresolution, overlapping video tiles and displayed in a web page by manipulating the HTML5 <video> tag, in much the same way that Google Maps first demonstrated using the HTML <img> tag.

Examples of zoomable timelapses with hundreds of millions or billions of pixels per frame include documenting plant growth, bee colony collapse, and very-large-scale simulations of the universe. Time-lapse Earth, however, sets a new record for giant videos: each frame of the video is a global Mercator-projected map with a resolution of 30 meters per pixel at the equator, for a total of 1.78 trillion pixels per frame. That’s about a million times larger than a standard HD video stream. In order to scale to such large videos, we needed to integrate Time Machine’s data production pipeline into Earth Engine and the rest of Google’s infrastructure. Encoding the final video tiles consumed approximately 1.4 million core-hours of CPU in Google’s data centers over the course of about a day. For CMUs researchers, this would have been impossible without Googles resources.

Combining all three phases of product generation:

• Total processing time: 3 days
• Total CPU usage: 1.8 million core-hours
• Peak CPU usage: 66,000 simultaneous cores

Destination locations of top 1500 share links, weighted by number of visits.

Time-lapse Earth is powerful because it helps us to access and construct the story of our planet. That story will become richer with each release, as we continue to improve fidelity and add data. The story-teller is everyone — scientists and citizens alike provide the real value by interacting, exploring, layering their knowledge upon the globe, and sharing their insights so that we can all better understand our world.

We are especially proud of the collaboration that made time-lapse Earth possible, and believe it to be an exemplar of how industry, academia, government, and the press can benefit from working together deeply over a period of years. By drawing on the strengths of each member of the collaborative community, Google strives to integrate the worlds technical expertise and knowledge in order to tackle innovative and groundbreaking projects. In doing so, it is our goal to deliver an impactful service, one that can put a focus on the dramatic effect we are having on our planet.

Read More..