Сотрудники университета Ватерлоо создали автономный ИИ, работающий без Интернета

https://tproger.ru/news/autonomous-ai/

Новый метод обучения ИИ сделает технологию более конфиденциальной и портативной.
Автономный ИИ

Технология, разработанная учёными университета Ватерлоо, поможет освободить ИИ от уз Интернета и облачных технологий. Новое ПО для глубинного обучения, созданное с использованием этой технологии, достаточно компактно, чтобы поместиться на вычислительных чипах устройств широкого спектра: от смартфонов до промышленных роботов.

По словам Александра Вонг, одного из профессоров университета и соавтора статьи, новая технология обладает огромным потенциалом. Предложенные им и его коллегами идеи станут своеобразным стимулом для учёных из разных технических областей, где существуют проблемы внедрения автономного ИИ.

Снижение затрат на поддержку ИИ

Использование автономного ИИ может привести к значительному снижению затрат на обработку и передачу данных, большей конфиденциальности и его внедрению в тех областях, где существующая технология нецелесообразна из-за расходов или других факторов.

Именно отправка собранных на конечном устройстве данных в облако для их последующей обработки и является самой затратной частью нынешнего подхода машинного обучения. Кроме того, необходимость значительных вычислительных мощностей, памяти и энергии для функционирования облачных сервисов явно не удешевляют и не приближают повсеместное применение ИИ.

Где использовать новую технологию?

В проведённых экспериментах учёные из Ватерлоо добились более чем 200-кратного сокращения размера ПО, используемого для задач распознавания объектов. Подобный компактный ИИ, встроенный в смартфон, сможет самостоятельно обучаться, при этом значительно сокращая использование данных и работая даже без Интернета.

Также новую технологию можно будет использовать в беспилотных летательных аппаратах, камерах наблюдения и на производстве. То есть в тех областях, где существуют проблемы с потоковой передачей данных и необходимость сохранения их конфиденциальности.

Источник: EurekAlert!

Вячеслав Шарунов

Ученые создали сверхнадёжную литий-ионную батарею

https://tproger.ru/news/new-stable-li-ion-battery/

Прототип новой гибкой батарейки продолжает вырабатывать электричество даже при погружении в соленую воду, насильной деформации и разрыве на части.

Литий-ионные батареи нашли широкое применение в современной электронике благодаря своей энергоемкости и отдаче. Однако токсичная, огнеопасная и невлагоустойчивая природа их составных частей — электролитов — серьёзно ограничивает возможности производства и варианты использования.

Простое решение

Этой проблемой занялись Мэрилендский университет вместе с лабораторией армии США и в 2015 году представили более безопасный и устойчивый жидкий электролит с большим содержанием соли («соль с водой»). Новый высококонценрированный электролит на водной основе стал прекрасным ответом на острую проблему использования воды в литий-ионных батареях. Он позволил расширить так называемое «окно стабильности» с 1,2 до 3 вольт, что существенно увеличило плотность энергии в новых батареях.

Команда учёных обернула водно-соляной электролит в полимерную матрицу поливинилового спирта, тем самым создав ещё более стабильный гелевый полимерный электролит (GPE). Этот GPE стал прекрасной основой для новой гибкой литий-ионной батареи, которой не страшны сгибы и сломы.

Форм-фактор сегодняшних литий-ионных батарей существенно ограничен входящими в состав возгораемыми электролитами. С такими компонентами требуются дополнительные усилия и материалы для обеспечения безопасности их использования. Думаю, разработанный водно-солевой электролит полностью перевернёт представление о методах производства и использования литий-ионных батарей.

Костас Герасопулос, главный исследователь лаборатории прикладной физики армии США

Неубиваемый аккумулятор

Чтобы на практике продемонстрировать возможности новой гибкой батареи, команда ученых устроила ей испытания на открытом воздухе. Гелевый электролит был обернут лишь в изоляционную термостойкую ленту для поддержания формы. В таком виде новая батарея без каких-либо перебоев питала вентилятор. Во время работы источник энергии опускали в морскую воду и отрезали от него кусочки, — новая батарея с успехом выдержала все суровые эксперименты.

Устойчивость и стабильность новой батареи могут быть с успехом примерены не только в бытовом, но и в военном промысле.

Источник: блог Futurity

Светлана Хачатурян

Релиз дистрибутива для исследования безопасности систем Kali Linux 2017.3

http://www.opennet.ru/opennews/art.shtml?num=47612

22.11.2017 19:56  Релиз дистрибутива для исследования безопасности систем Kali Linux 2017.3

Вышел релиз дистрибутива Kali Linux 2017.3, предназначенного для тестирования систем на предмет наличия уязвимостей, проведения аудита, анализа остаточной информации и выявления последствий атак злоумышленников. Все оригинальные наработки, созданные в рамках дистрибутива, распространяются под лицензией GPL и доступны через публичный Git-репозиторий. Для загрузки подготовлен полный iso-образ, размером 2.7 Гб. Сборки доступны для архитектур x86, x86_64, ARM(armhf и armel, Raspberry Pi, ARM Chromebook, Odroid). Помимо базовой сборки с GNOME и урезанной версии предлагаются варианты с Xfce, KDE, MATE, LXDE и Enlightenment e17.

Kali включает одну из самых полных подборок инструментов для специалистов в области компьютерной безопасности: от средств для тестирования web-приложений и проникновения в беспроводные сети, до программ для считывания данных с идентификационных RFID чипов. В комплект входит коллекция эксплоитов и более 300 специализированных утилит для проверки безопасности, таких как Aircrack, Maltego, SAINT, Kismet, Bluebugger, Btcrack, Btscanner, Nmap, p0f. Помимо этого, в дистрибутив включены средства для ускорения подбора паролей (Multihash CUDA Brute Forcer) и WPA ключей (Pyrit) через задействование технологий CUDA и AMD Stream, позволяющих использовать GPU видеокарт NVIDIA и AMD для выполнения вычислительных операций.

В новом выпуске выполнена синхронизация пакетов с Debian Testing и обновлены специфичные для Kali приложения, такие как ReaverPixieWPSBurp SuiteCuckoo и Social Engineering Toolkit. Задействовано ядро Linux 4.13, в котором появилась встроенная поддержка TLS. Объединены инструменты для сбора информации Maltego и Casefile.

В состав включена порция новых инструментов:

  • InSpy — утилита для поиска людей в LinkedIn на основании заданных признаков (например, можно выбрать работников определённой компании для целевого применения методов социальной инженерии);
  • CherryTree — приложение для ведения заметок;
  • Sublist3r — утилита для определения существующих поддоменов через перебор по словарю;
  • OSRFramework — коллекция скриптов для перебора пользователей и доменов для 290 сервисов.

Нейросети для чайников. Начало

https://habrahabr.ru/post/143129/

Нейросети для чайников. Начало

Так получилось, что в университете тема нейросетей успешно прошла мимо моей специальности, несмотря на огромный интерес с моей стороны. Попытки самообразования несколько раз разбивались невежественным челом о несокрушимые стены цитадели науки в облике непонятных «с наскока» терминов и путанных объяснений сухим языком вузовских учебников.

В данной статье (цикле статей?) я попытаюсь осветить тему нейросетей с точки зрения человека непосвященного, простым языком, на простых примерах, раскладывая все по полочкам, а не «массив нейронов образует перцептрон, работающий по известной, зарекомендовавшей себя схеме».

Заинтересовавшихся прошу под кат.

Цели

Для чего же нужны нейросети?
Нейросеть – это обучаемая система. Она действует не только в соответствии с заданным алгоритмом и формулами, но и на основании прошлого опыта. Этакий ребенок, который с каждым разом складывает пазл, делая все меньше ошибок.

И, как принято писать у модных авторов – нейросеть состоит из нейронов.
Тут нужно сделать остановку и разобраться.

Договоримся, что нейрон – это просто некая воображаемая чёрная коробка, у которой кучка входных отверстий и одно выходное.
Причем как входящая, так и исходящая информация может быть аналоговой (чаще всего так и будет).

Как выходной сигнал формируется из кучи входных – определяет внутренний алгоритм нейрона.

Для примера напишем небольшую программу, которая будет распознавать простые изображения, скажем, буквы русского языка на растровых изображениях.
Условимся, что в исходном состоянии наша система будет иметь «пустую» память, т.е. этакий новорожденный мозг, готовый к бою.
Для того чтобы заставить его корректно работать, нам нужно будет потратить время на обучение.

Уворачиваясь от летящих в меня помидоров, скажу, что писать будем на Delphi (на момент написания статьи была под рукой). Если возникнет необходимость – помогу перевести пример на другие языки.

Также прошу легкомысленно отнестись к качеству кода – программа писалась за час, просто чтобы разобраться с темой, для серьезных задач такой код вряд ли применим.

Итак, исходя из поставленной задачи — сколько вариантов выхода может быть? Правильно, столько, сколько букв мы будем уметь определять. В алфавите их пока только 33, на том и остановимся.

Далее, определимся со входными данными.Чтобы слишком не заморачиватсья – будем подавать на вход битовый массив 30х30 в виде растрового изображения:

В итоге – нужно создать 33 нейрона, у каждого из которых будет 30х30=900 входов.
Создадим класс для нашего нейрона:

type
  Neuron = class
    name: string; // Тут название нейрона – буква, с которой он ассоциируется
    input: array[0..29,0..29] of integer; // Тут входной массив 30х30
    output:integer; // Сюда он будет говорить, что решил 
    memory:array[0..29,0..29] of integer; // Тут он будет хранить опыт о предыдущем опыте
  end;

Создадим массив нейронов, по количеству букв:

For i:=0 to 32 do begin
neuro_web[i]:=Neuron.Create;
neuro_web[i].output:=0; //  Пусть пока молчит
 neuro_web[i].name:=chr(Ord('A')+i); // Буквы от А до Я
end;

Теперь вопрос – где мы будем хранить «память» нейросети, когда программа не работает?
Чтобы не углубляться в INI или, не дай бог, базы данных, я решил хранить их в тех же растровых изображениях 30х30.
Вот например, память нейрона «К» после прогона программы по разным шрифтам:

Как видно, самые насыщенные области соответствуют наиболее часто встречаемым пикселям.
Будем загружать «память» в каждый нейрон при его создании:

p:=TBitmap.Create;
     p.LoadFromFile(ExtractFilePath(Application.ExeName)+'\res\'+ neuro_web[i].name+'.bmp')

В начале работы необученной программы, память каждого нейрона будет белым пятном 30х30.

Распознавать нейрон будет так:

— Берем 1й пиксель
— Сравниваем его с 1м пикселем в памяти (там лежит значение 0..255)
— Сравниваем разницу с неким порогом
— Если разница меньше порога – считаем, что в данной точке буква похожа на лежащую в памяти, добавляем +1 к весу нейрона.

И так по всем пикселям.

Вес нейрона – это некоторое число (в теории до 900), которое определяется степенью сходства обработанной информации с хранимой в памяти.
В конце распознавания у нас будет набор нейронов, каждый из которых считает, что он прав на сколько-то процентов. Эти проценты – и есть вес нейрона. Чем больше вес, тем вероятнее, что именно этот нейрон прав.

Теперь будем скармливать программе произвольное изображение и пробегать каждым нейроном по нему:

for x:=0 to 29 do
             for y:=0 to 29 do begin
                 n:=neuro_web[i].memory[x,y]; 
                 m:=neuro_web[i].input[x,y];

                 if ((abs(m-n)<120)) then // Порог разницы цвета
                if m<250 then  neuro_web[i].weight:=neuro_web[i].weight+1; // Кроме того, не будем учитывать белые пиксели, чтобы не получать лишних баллов в весах
                if m<>0 then   begin
                  if m<250 then   n:=round((n+(n+m)/2)/2);
                      neuro_web[i].memory[x,y]:=n;   end
                else if n<>0 then
                  if m<250 then    n:=round((n+(n+m)/2)/2);
               neuro_web[i].memory[x,y]:=n;

             end;

Как только закончится цикл для последнего нейрона – будем выбирать из всех тот, у которого вес больше:

if neuro_web[i].weight>max then  begin
         max:=neuro_web[i].weight;
         max_n:=i;
         end;

Именно по вот этому значению max_n, программа и скажет нам, что, по её мнению, мы ей подсунули.
По началу это будет не всегда верно, поэтому нужно сделать алгоритм обучения.


s:=InputBox('Enter the letter', ‘программа считает, что это буква ’+neuro_web[max_n].name, neuro_web[max_n].name);
     for i:=0 to 32 do     begin //Пробегаем по нейронам
     if neuro_web[i].name=s then begin //В нужном нейроне обновляем память
for x:=0 to 29 do   begin
    for y:=0 to 29 do        begin
     p.Canvas.Pixels[x,y]:=RGB(neuro_web[i].memory[x,y],neuro_web[i].memory[x,y], neuro_web[i].memory[x,y]); //Записываем новое значение пикселя памяти
     end;
      end;
       p.SaveToFile(ExtractFilePath(Application.ExeName)+'\res\'+ neuro_web[i].name+'.bmp');

Само обновление памяти будем делать так:

n:=round(n+(n+m)/2);    

Т.е. если данная точка в памяти нейрона отсутствует, но учитель говорит, что она есть в этой букве – мы её запоминаем, но не полностью, а только наполовину. С дальнейшим обучением, степень влияния данного урока будет увеличиваться.

Вот несколько итераций для буквы Г:

На этом наша программа готова.

Обучение

Начнем обучение.
Открываем изображения букв и терпеливо указываем программе на её ошибки:

Через некоторое время программа начнет стабильно определять даже не знакомые ей ранее буквы:

Заключение

Программа представляет собой один сплошной недостаток – наша нейросеть очень глупа, она не защищена от ошибок пользователя при обучении и алгоритмы распознавания просты как палка.
Зато она дает базовые знания о функционировании нейросетей.

Если данная статья заинтересует уважаемых хабравчан, то я продолжу цикл, постепенно усложняя систему, вводя дополнительные связи и веса, рассмотрю какую-нибудь из популярных архитектур нейросетей и т.д.

Поиздеваться над нашим свежерожденный интеллектом вы можете, скачав программу вместе с исходниками тут.

За сим откланяюсь, спасибо за чтение.

UPD: У нас получилась заготовка для нейросети. Пока что это ещё ей не является, но в следующей статье мы постараемся сделать из неё полноценную нейросеть.
Спасибо Shultc за замечание.

Нейросети для чайников. Часть 2 — Перцептрон

image

В предыдущей статье были рассмотрены самые азы для понимания темы нейронных сетей. Полученная система не являлась полноценной нейронной сетью, а несла просто ознакомительный характер. Принимающими решения механизмами в ней были «черные ящики», не описанные подробно.
Вот о них речь и пойдет в рамках данной статьи. Результатом статьи будет полноценная нейронная сеть из одного перцептрона, умеющая распознавать входные данные и позволяющая себя обучать.

Язык программирования, на этот раз — C#.
Заинтересовавшихся прошу под кат.

Изложение буду вести простым языком, поэтому профи прошу не критиковать за терминологию.

В первой статье, элементом, отвечающим за распознавание конкретной цифры, был некий «нейрон» (таковым, по сути, не совсем являвшийся, но принятый за него для простоты).
Рассмотрим, что же он из себя представляет.

На вход мы снова будем подавать изображение, поэтому входные данные представляют собой двумерный массив. Далее, каждый кусочек входных данных соединяется с нейроном с помощью специальной связи (синапса) — на рисунке красные линии. Но это не простые связи. Каждая из них имеет какую-то значимость для нейрона.
Приведу аналогию с человеком. Мы воспринимаем информацию разными органами чувств — видим, слышим, чуем, осязаем. Но некоторые из этих чувств имеют более высокий приоритет (зрение), а некоторые более низкий (чутье, осязание). Причем для каждой жизненной ситуации приоритет для каждого органа чувств мы задаем основываясь на своем опыте — готовясь съесть незнакомый продукт, мы ставим в максимальный приоритет зрение и обоняние, а вот слух не играет роли. А пытаясь в толпе людей найти своего друга, мы обращаем внимание на информацию, которую дают нам глаза и уши, а остальное отходит на второй план.
Простейшим подобием отдельного органа у нейрона и является синапс. В разных ситуациях разные синапсы будут иметь разную значимость. Эта значимость называется весом связи.

Т.к. подаваемая на вход картинка у нас черно-белая, то на входе аксона может быть только 1 или 0:

А на выходе либо значение веса, либо 0.
Грубо говоря, если на входе что-то есть — ножка начинает «дёргаться», говоря нейрону, что на ней есть информация. От того, как сильно она «дёргается», будет зависеть принимаемое сетью решение.
Количество аксонов соответствует числу элементов входного массива. В данной статье я буду использовать в качестве входной информации изображения размерами 3х5 пикселей. Соответственно, число связей, приходящих в нейрон будет 3 х 5 = 15.

Сигнал, отмасштабированный коэффициентом веса связи, приходит в нейрон, где складывается с остальными сигналами от прочих синапсов.
Получается некоторое число. Это число сравнивается с заранее установленным порогом — если полученное значение выше порога, то считается, что нейрон выдал на выход единицу.
Порог выбирается из следующих соображений: чем он выше, тем больше будет точность работы нейрона, но тем дольше нам придется его обучать.

Перейдем к программной реализации.
Создадим класс нейрона:

class Web
        {
            public int[,] mul; // Тут будем хранить отмасштабированные сигналы
            public int[,] weight; // Массив для хранения весов
            public int[,] input; // Входная информация
            public int limit = 9; // Порог - выбран экспериментально, для быстрого обучения
            public int sum ; // Тут сохраним сумму масштабированных сигналов

            public Web(int sizex, int sizey,int[,] inP) // Задаем свойства при создании объекта
            {
                weight = new int[sizex, sizey]; // Определяемся с размером массива (число входов)
                mul = new int[sizex, sizey];

                input = new int[sizex, sizey];
                input = inP; // Получаем входные данные
            }

Да, я знаю, что процедуры умножения сигнала на вес, суммирования сигналов, сравнения с порогом и выдачи результата можно было объединить в одном месте. Но мне показалось, что будет понятнее, если мы проведем каждую операцию по-отдельности и вызовем их поочередно:

Масштабирование:

            public void mul_w()
            {
                for (int x = 0; x <= 2; x++)
                {
                    for (int y = 0; y <= 4; y++) // Пробегаем по каждому аксону
                    {
                        mul[x, y] = input[x,y]*weight[x,y]; // Умножаем его сигнал (0 или 1) на его собственный вес и сохраняем в массив.
                    }
                }
            }

Сложение:

            public void Sum()
            {
                sum = 0;
                for (int x = 0; x <= 2; x++)
                {
                    for (int y = 0; y <= 4; y++)
                    {
                        sum += mul[x, y];
                    }
                }
            }

Сравнение:

            public bool Rez()
            {
                if (sum >= limit)
                    return true;
                else return false;
            }

Программа будет открывать файл-картинку такого вида:

Пробегать по всем пикселям и пытаться определить, является ли эта цифра той, которую её научили распознавать.
Т.к. у нас нейрон только один, то и распознавать мы сможем только один символ. Я выбрал цифру 5. Иными словами, программа будет говорить нам — является скормленная ей картинка изображением цифры 5 или нет.

Чтобы программа могла продолжить работу после выключения, я буду сохранять значения весов в текстовый файл.

        private void Form1_Load(object sender, EventArgs e)
        {
           

            NW1 = new Web(3, 5,input); // Создаем экземпляр нашего нейрона

            openFileDialog1.Title = "Укажите файл весов";
            openFileDialog1.ShowDialog();
            string s = openFileDialog1.FileName;
            StreamReader sr = File.OpenText(s);  // Загружаем файл весов
            string line;
            string[] s1;
            int k = 0;
            while ((line = sr.ReadLine()) != null)
            {
               
                s1 = line.Split(' ');
                for (int i = 0; i < s1.Length; i++)
                {
                    listBox1.Items.Add("");
                    if (k < 5)
                    {
                        NW1.weight[i, k] = Convert.ToInt32(s1[i]); // Назначаем каждой связи её записанный ранее вес
                        listBox1.Items[k] += Convert.ToString(NW1.weight[i, k]); // Выводим веса, для наглядности
                    }

                }
                k++;

            }
            sr.Close();
        }

Далее, необходимо сформировать массив входных данных:

            Bitmap im = pictureBox1.Image as Bitmap;
            for (var i = 0; i <= 5; i++) listBox1.Items.Add(" ");

            for (var x = 0; x <= 2; x++)
            {
                for (var y = 0; y <= 4; y++)
                {
                  
                    int n = (im.GetPixel(x, y).R);
                    if (n >= 250) n = 0; // Определяем, закрашен ли пиксель
                    else n = 1;
                    listBox1.Items[y] = listBox1.Items[y] + "  " + Convert.ToString(n);

                    input[x, y] = n; // Присваиваем соответствующее значение каждой ячейке входных данных

                }

            }

Распознаем символ, вызывая описанные выше методы класса:

        public void recognize()
        {
            NW1.mul_w();
            NW1.Sum();
            if (NW1.Rez()) listBox1.Items.Add(" - True, Sum = "+Convert.ToString(NW1.sum));
            else listBox1.Items.Add( " - False, Sum = "+Convert.ToString(NW1.sum));
        }

Все. Теперь наша программа уже может называться нейронной сетью и что-то определять.
Однако, она совсем глупа и всегда выдает False.
Необходимо обучить её. Обучать будем по простейшему алгоритму.

Если сеть выдает правильный ответ — радуемся и ничего не делаем.
А если ошибается — наказываем её соответствующим образом:

— Если её неправильный ответ False, то прибавляем значения входов к весам каждой ножки (к ножке 1 — значение в точке [0,0] картинки и т.д.):

            public void incW(int[,] inP)
            {
                for (int x = 0; x <= 2; x++)
                {
                    for (int y = 0; y <= 4; y++)
                    {
                        weight[x, y] += inP[x, y];
                    }
                }
            }

— Если её неправильный ответ True, то вычитаем значения входов из веса каждой ножки:

            public void decW(int[,] inP)
            {
                for (int x = 0; x <= 2; x++)
                {
                    for (int y = 0; y <= 4; y++)
                    {
                        weight[x, y] -= inP[x, y];
                    }
                }
            }

Затем сохраняем полученные изменения в массиве весов и продолжаем обучение.
Как я уже сказал, я взял для образца цифру 5: 

Кроме того, я приготовил остальные цифры и несколько вариантов самой цифры 5:

Вполне ожидаемо, что самой проблемной будет цифра 6, однако и это мы преодолеем с помощью обучения.
Создаем текстовый файл, заполненный нулями 3х5 — чистая память нашей сети:

000
000
000
000
000

Запускаем программу и указываем ей на этот файл.
Загружаем картинку цифры 5:

Естественно, ответ неверный. Нажимаем «Не верно».
Происходит перерасчет весов (можете посмотреть результат в файле):

1 1 1
1 0 0
1 1 1
0 0 1
1 1 1

Теперь программа будет корректно распознавать эту картинку.
Продолжаем скармливать нашей программе картинки и наказывать её за неправильные ответы.
В конечном итоге она будет распознавать все картинки из набора безошибочно.
Вот итоговые значения весов, сохраненные в файл моей полностью настроенной сетью:

1 2 1
1 0 -4
1 2 1
-4 0 1
1 1 0

Вот и шестерка определяется корректно.

Исходные коды программы, исполняемый файл, файлы весов и картинок 3х5 можно взять отсюда.
Если хотите поиграться с другими символами или обучить сеть заново — не забудьте обнулить все цифры в файле w.txt

На этом я заканчиваю статью, дорогие хабражители. Мы научились создавать, настраивать и обучать простейший перцептрон.
Если статья встретит горячие отзывы, в следующий раз попробуем реализовать что-то более сложное и многослойное. Кроме того, остался неосвещенным вопрос оптимального (быстрого) обучения сети.

За сим откланяюсь, спасибо за чтение.

 

Facebook //контакты

https://gizmodo.com/how-facebook-figures-out-everyone-youve-ever-met-1819822691

Часто в социальных сетях люди видят в предлагаемых контактах тех, кого они встречали в жизни всего пару раз и, вроде бы, никак в интернете с ними не пересекались. Обычно под такую категорию попадают те люди, кто кардинально отличается от вас кругами общения: например, выпускник другого вуза живущий в другом городе и работающий в совершенно другом виде деятельности, без общих знакомых — это довольно неочевидный выбор как «предлагаемый друг».
Первым в голову приходит ваш список контактов телефона: если вы включили их импорт в Facebook, то логично, что социальная сеть сможет предложить вам человека в друзья по совпадению его телефона/email. Другой момент в том, что далеко не все пользуются данной, довольно устрашающей функцией, — всё-таки иногда встречается дельная мысль, что Facebook необязательно знать номера всех людей, которых вы добавили в записную книгу телефона, мало ли чего из этой информации можно получить.
Но, даже в этом случае, возникает непредсказуемый фактор второго человека, потому что большинство людей всё же отдаёт Facebook информацию о своей записной книге, где как раз и может оказаться ваш номер телефона. В итоге получается так, что любой человек, с которым вы когда-либо обменивались номерами, в реальном времени «сливает» эту информацию интернет-гиганту, и помешать этому, по сути, можно только давая другие контакты, которые никак не ассоциированы с Facebook. О дивный новый мир.

В Instagram появились запросы на просмотр прямых эфиров друзей.

Подключить к трансляции можно с помощью специальной кнопки «Отправить запрос», расположенной в разделе комментариев к прямому эфиру. Как только запрос будет одобрен, вы получите подтверждение. Сразу после старта совместной трансляции экран будет разделен на две части.

В любой момент организатор трансляции может отказать пользователю на подключение к прямой трансляции или вовсе отключить его от эфира.

photo_2017-11-23_12-44-27.jpg

Telegram

Всего за год приложение скачали более 73 млн раз.

photo_2017-11-23_20-23-52.jpg