While this discipline aims to give the ability of sight to a machine, it stands for not only trying to understand the creature that has the best visual ability, and how that creature senses/perceives the world but also considering the goal of “the best seeing”.

Then, here is Stomatopoda, the creature that has the best visual system in the world! (Best known as Mantis shrimp)

The eyes of Mantis shrimps, or stomatopods, are mounted on movable stalks and can move without being dependent to each other. It is thought that they have the most complex eyes and the visual systems in the animal kingdom. Some breakthrough advancements in technology such as the development of next-generation communication systems might be resulted from the eyes of mantis shrimps. The eyes of Mantis shrimps can perceive at least 100,000 colors which is ten multiple of the humans’.

Let's Get to Know the Stomatopodas Better

Mantis shrimps, or Stomatopods, are carnivorous marine crustaceans of the order Stomatopoda, which branched out from other members of the Malacostraca class about 340 million years ago.

Each living thing on the earth has a different eyesight. In our eyes, there are receptors that allow us to see colors. Dogs have two types of photoreceptors (green and blue), while humans have three types (red, green, and blue). Moreover, birds have four types of photoreceptors (red, green, blue and UV). How many photoreceptors do you think Mantis shrimps have?

Mantis shrimps have 16 types of receptors. Twelve of these receptors are responsible for color perception and the other four are responsible for color filtering. Neurologist Daniel Osorio from the University of Sussex likens this situation to wearing tinted glasses and says that: 'These filters block some frequencies of light while allowing others to pass through. This can be compared to wearing glasses with yellow lenses to reduce the blue light and increase clarity in cloudy weather.'

Mantis shrimps actively fluoresce during their mating rituals, and the wavelength of this fluorescence matches the wavelengths detected by the eye pigments. Females are fertile only during certain phases of the tidal cycle. Therefore, the ability to sense the phase of the moon can help prevent wasted mating efforts. Also, this situation can give information about the extent of the tide to the shrimps, which is very important for species that live in shallow water. Thanks to their superior vision, they can calculate the depth and the distance between an object and themselves. Thus, it even becomes impossible for us to imagine what the Mantis shrimps perceive.

The eyes of mantis shrimps, which were set on stalks, can be turned as fast as several hundred degrees per second. As a result, they have a very wide field of view. Mantis shrimps can use all three visual regions in their eyes simultaneously. It can have a tri-central (trinocular) vision, taking the binocular vision seen in many animal species, including humans, one step further.

The light range that mantis shrimps can see is also much wider than that of humans. They can easily see even the lights in the infrared and ultraviolet area for humans. Humans can see from the 400-nanometer wavelength of the blue light to the 700-nanometer wavelength of the red light. Furthermore, Mantis shrimps can range from 250-300 nanometers (which we don't have colors to define, we define ultraviolet) to 800-900 nanometers (similarly, we can only define this as infrared)

Inspired Engineers Aim to Develop Advanced Systems

Mantis shrimps, thanks to their eyes which have a feature that is not found in any other creature in the animal kingdom, can perceive light known as a circular polarizing filter (CPL). CPL is formed by the 360-degree rotation of electromagnetic waves around the axis of a light beam. This ability of the Mantis shrimps, who are the only creature in the world with the perception of CPL, was discovered in 2008. This feature of the shrimp was first announced in March of the same year by the Current Biology journal. Inspired by this, engineers aim to develop advanced technology communication systems in which light can be used much more effectively thanks to the CPL sensing ability of Mantis shrimps.

The engineers intend to improve the image quality by obtaining a much stronger resolution by the ability of the free rotation movement of the light, as in CPL.

Researchers suspect that wider diversity of photoreceptors in the eyes of Mantis shrimps allows visual information to be preprocessed by the eyes rather than the brain. Otherwise, their brains would have to be bigger to deal with the complex task of color perception. While their eyes are so complex and have not yet been fully understood, the principle of the system seems simple. It has a similar set of sensitivities to the human visual system; but however, it works in the opposite way. In human brains, the inferior temporal cortex has a large number of color-specific neurons that process visual stimuli from the eyes to create colorful experiences. The mantis shrimp instead uses different types of photoreceptors in its eyes to perform the same function as human brain neurons, resulting in a more efficient system for an animal that requires fast color identification. Humans have fewer types of photoreceptors, and even there are more color-tuned neurons, Mantis shrimps seem to have fewer color neurons and more photoreceptor classes.

According to a paper from the University of Queensland, the compound eyes of Mantis shrimp can detect cancer and the activity of neurons because they are sensitive enough to differentiate the polarized lights that are reflected from a cancerous tissue or a healthy tissue. The study claims that this ability could be replicated via a camera through the use of aluminum nanowires to replicate polarization-filtering microvilli on photodiodes.

This article is compiled from the following sources. I would like to thank Zehra Nur Günindi and Muhammed Emin Arayıcı for their valuable contributions and translation support in the creation of the article.

►►Sources:

• https://core.ac.uk/download/pdf/43365607.pdf
• https://www.avaschroedl.com/vision-in-mantis-shrimp
• https://www.scientificamerican.com/article/camera-mimics-mantis-shrimps-astounding-vision/
• https://aeon.co/videos/how-the-mantis-shrimps-six-pupiled-eyes-put-2020-vision-to-shame
• https://www.npr.org/sections/health-shots/2016/11/15/501443254/watch-mantis-shrimps-incredible-eyesight-yields-clues-for-detecting-cancer
• https://www.science.org.au/curious/earth-environment/all-eyes-reef
• https://stringfixer.com/en/Stomatopod
• https://en.wikipedia.org/wiki/Mantis_shrimp
• https://www.bilimup.com/evrenin-en-guclu-bokscusu-mantis-karidesi
• https://evrimagaci.org/dunyanin-en-guclu-yumrugu-mantis-karidesi-1091
• https://evrimagaci.org/gorme-yetimiz-anlamsiz-kilan-hayvan-mantis-karidesi-1151
• https://en.peopleperproject.com/posts/5169-mantis-shrimp-facts-stomatopoda
• http://kusursuzyaratilis.com/mukemmel-gozlere-sahip-mantis-karidesi/
• https://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=6880796
• https://ieeexplore.ieee.org/document/6880796
• https://www.hayretedecek.com/dunyanin-en-guclu-canlisi-mantis-karidesi/
• https://www.ntboxmag.com/2018/10/12/mantis-karidesinde-esinlenen-kamera-gelistiriyor/
• https://www.hurriyet.com.tr/dunya/umut-bu-iki-goze-baglandi-14504503
• https://www.youtube.com/watch?v=eGuZifKr0h4&ab_channel=LoveNature
• https://www.youtube.com/watch?v=t2FTavvZt_c
• https://www.youtube.com/watch?v=ujrsE3ljcv4

Bilgisayarlı Görü, bilgisayarların dijital görüntülerden veya videolardan nasıl bir anlam kazanabileceğiyle ilgilenen disiplinler arası bilimsel bir alandır. Bu disiplin örneğin bir makineye görme yetisi kazandırmayı hedeflerken, tabi ki en iyi gören canlıyı ve onun dünyayı nasıl algiladigini anlamaya çalışmak, “en iyi görme” hedefini de belirlemek anlamına gelir.

O halde işte karşınızında dünyanın en iyi görsel sistemine sahip canlısını Stomatopoda! (Daha yaygın bilinen adıyla Mantis karidesi)

Mantis karidesi veya stomatopod’larin gözleri hareketli saplara monte edilmiştir ve birbirinden bağımsız hareket edebilir. Hayvanlar alemindeki en karmaşık gözlere ve görsel sisteme sahip oldukları düşünülüyor. Mantis karideslerinin sahip olduğu gözler, yeni nesil iletişim sistemleri geliştirilmesini sağlayarak teknolojide çığır açabilir. Gözleri en az 100 bin rengi algılaması sağlayan çok sayıda hücreye sahip bulunuyor. Bu rakam insan gözünün algılayabildiği renk sayısının 10 katı.

Stomatopoda’ları Daha İyi Tanıyalım

Mantis karidesi veya stomatopodlar, yaklaşık 340 milyon yıl önce Malacostraca sınıfının diğer üyelerinden dallanan Stomatopoda takımının etçil deniz kabuklularıdır.

Yeryüzündeki bütün canlıların görme yetenekleri birbirinden farklıdır. Gözlerimizde renkleri görmemizi sağlayan reseptörler vardır. Köpeklerde iki fotoreseptör (yeşil ve mavi), insanlarda üç fotoreseptör (mavi, kırmızı ve yeşil), kuşlarda ise dört fotoreseptör ( kırmızı, yeşil, mavi ve UV) vardır. Peki sizce Mantis karidesleri kaç fotoreseptöre sahiptir?

Mantis karideslerinin tam 16 çeşit reseptörü vardır. Bu reseptörlerin 12 tanesi renk algısı, 4 tanesi de renk filtresi içindir. Sussex Üniversitesi’nden nörolog Daniel Osorio bu durumu renkli gözlük takmaya benzetir ve şöyle anlatır: ‘Bu filtreler bazı frekanstaki ışıkları engellerken bazılarının da geçmesine izin verir. Bunu mavi ışığı azaltmak ve bulutlu havalarda netliği arttırmak için sarı mercekli gözlük takmaya benzetebiliriz.’

Mantis karidesleri çiftleşme ritüelleri sırasında aktif olarak flüoresans yayarlar ve bu flüoresansın dalga boyu göz pigmentleri tarafından tespit edilen dalga boylarıyla eşleşir. Dişiler yalnızca gelgit döngüsünün belirli evrelerinde doğurgandır. Bu nedenle, ayın evresini algılama yeteneği, boşa giden çiftleşme çabalarını önlemeye yardımcı olabilir. Ayrıca bu karideslere, kıyıya yakın sığ sularda yaşayan türler için önemli olan gelgitin boyutu hakkında bilgi verebilir. Bu üstün görme yetenekleri sayesinde derinliği ve tüm nesnelerin kendisine olan uzaklığını hesaplayabilmektedirler. Böylece Mantis karideslerinin algıladıklarını hayal bile etmemiz imkânsız hale gelir.

Sapların üzerine yerleşmiş gözleri saniyede birkaç yüz derece çevrilebilecek kadar hızlı hareket eder. Böylece çok geniş bir görüş alanına sahip olur. Gözündeki üç görsel bölgeyi de eşzamanlı olarak kullanabilmektedir. İnsan da dahil olmak üzere birçok hayvan türünde görülen dürbünsel (binoküler) görüşü bir kademe öteye taşıyarak, üç-merkezli (trinoküler) görüşe sahip olabilmektedir.

Mantis karideslerinin görebildiği ışık aralığı da insandan çok daha geniştir. İnsan için kızılötesi ve morötesi olan alandaki ışıkları bile çok rahatlıkla görebilmektedirler. İnsan mavi ışığın 400 nanometrelik dalga boyundan, kırmızı ışığın 700 nanometrelik dalga boyuna kadar görebilmektedir. Mantis karidesleri ise 250-300 nanometreden başlayıp (ki burasını tanımlayabilecek renklere sahip değiliz, mor ötesi olarak tanımlamaktayız) 800-900 nanometreye kadar ulaşabilmektedirler (ki benzer şekilde biz burayı sadece kızılötesi olarak tanımlayabiliyoruz)

İlham Alan Mühendisler İleri Sistemleri Geliştirmeyi Hedefliyor

Gözleri sayesinde hayvanlar âleminde diğer hiçbir canlıda olmayan bir özelliğe sahip olan Mantis karidesleri dairesel polarize filtre (CPL) olarak bilinen ışığı algılayabiliyorlar. CPL, bir ışık doğrusunun ekseni etrafındaki elektromanyetik dalgaların, 360 derece dönmesiyle oluşuyor. Dünyada CPL algısına sahip tek canlı olan Mantis karidesinin bu yeteneği 2008 yılında keşfedildi. Karidesin bu özelliği ilk olarak aynı yıl Mart ayında Current Biology dergisi tarafından duyuruldu. Bu noktadan ilham alan mühendisler, Mantis karideslerinin CPL algılama yeteneği sayesinde, ışığın çok daha etkin kullanılabileceği ileri teknoloji iletişim sistemleri geliştirmeyi hedefliyor. Mühendisler, ışığın CPL’de olduğu gibi serbest dönüş hareketinden faydalanılması sayesinde, çok daha güçlü çözünürlük elde ederek görüntü kalitesini artırmayı amaçlıyor.

Araştırmacılar, Mantis karideslerinin gözlerindeki daha geniş fotoreseptör çeşitliliğinin, görsel bilginin beyin yerine gözler tarafından önceden işlenmesine izin verdiğinden şüpheleniyorlar. Aksi takdirde, beyinlerinin renk algısının karmaşık göreviyle başa çıkmak için daha büyük olması gerekirdi. Gözlerin kendisi karmaşık ve henüz tam olarak anlaşılmamış olsa da, sistemin prensibi basit görünüyor. İnsan görsel sistemine benzer bir dizi duyarlılığa sahiptir, ancak tam tersi şekilde çalışır. İnsan beyninde, alt temporal korteks, renkli deneyimler yaratmak için gözlerden gelen görsel uyarıları işleyen çok sayıda renge özgü nörona sahiptir. Mantis karidesi bunun yerine, insan beyni nöronlarıyla aynı işlevi gerçekleştirmek için gözlerindeki farklı tipteki fotoreseptörleri kullanır, bu da hızlı renk tanımlaması gerektiren bir hayvan için daha verimli bir sistemle sonuçlanır. İnsanlarda daha az fotoreseptör türü var ancak daha fazla renk ayarlı nöron varken, mantis karidesleri daha az renk nöronuna ve daha fazla fotoreseptör sınıfına sahiptir.

Queensland Üniversitesi'nden araştırmacılar tarafından yapılan bir yayın, mantis karidesinin bileşik gözlerinin kanseri ve nöronların aktivitesini tespit edebileceğini çünkü kanserli ve sağlıklı dokudan farklı şekilde yansıyan polarize ışığı algılamaya duyarlı olduklarını belirtti. Çalışma, bu yeteneğin, fotodiyotların üzerinde polarizasyon filtreleyen mikrovillileri çoğaltmak için alüminyum nanotellerin kullanımı yoluyla bir kamera aracılığıyla kopyalanabileceğini iddia ediyor.

Bu yazı aşağıdaki kaynaklardan derlenmiş bir çalışmadır. Yazının oluşmasında değerli katkıları ve çeviri desteklerinden dolayı Zehra Nur Günindi ve Muhammed Emin Arayıcı’ya teşekkür ederim.

►►Kaynaklar:

• https://core.ac.uk/download/pdf/43365607.pdf
• https://www.avaschroedl.com/vision-in-mantis-shrimp
• https://www.scientificamerican.com/article/camera-mimics-mantis-shrimps-astounding-vision/
• https://aeon.co/videos/how-the-mantis-shrimps-six-pupiled-eyes-put-2020-vision-to-shame
• https://www.npr.org/sections/health-shots/2016/11/15/501443254/watch-mantis-shrimps-incredible-eyesight-yields-clues-for-detecting-cancer
• https://www.science.org.au/curious/earth-environment/all-eyes-reef
• https://stringfixer.com/tr/Stomatopod
• https://en.wikipedia.org/wiki/Mantis_shrimp
• https://www.bilimup.com/evrenin-en-guclu-bokscusu-mantis-karidesi
• https://evrimagaci.org/dunyanin-en-guclu-yumrugu-mantis-karidesi-1091
• https://evrimagaci.org/gorme-yetimizi-anlamsiz-kilan-hayvan-mantis-karidesi-1151
• https://tr.peopleperproject.com/posts/5169-mantis-shrimp-facts-stomatopoda
• http://kusursuzyaratilis.com/mukemmel-gozlere-sahip-mantis-karidesi/
• https://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=6880796
• https://ieeexplore.ieee.org/document/6880796
• https://www.hayretedeceksin.com/dunyanin-en-guclu-canlisi-mantis-karidesi/
• https://www.ntboxmag.com/2018/10/12/mantis-karidesinden-esinlenen-kamera-gelistiriliyor/
• https://www.hurriyet.com.tr/dunya/umut-bu-iki-goze-baglandi-14504503
• https://www.youtube.com/watch?v=eGuZifKr0h4&ab_channel=LoveNature
• https://www.youtube.com/watch?v=t2FTavvZt_c
• https://www.youtube.com/watch?v=ujrsE3ljcv4

Hayatınız iki yoldan değişir: tanıştığınız insanlar ve okuduğunuz kitaplar vasıtasıyla. Eğer yeni kitaplar okumazsanız ne olur biliyor musunuz? Değişmessiniz. Ve değişmiyorsanız büyümüyorsunuz demektir. Bu kadar basit. (Diri Diri Yenmeden Köpekbalıklarıyla Yüzmek! adlı bestseller'in yazarı Harvey B. Mackay okumanın gücü hakkında sözleri)

Arkadaşım İlker Aytı ile birlikte naçizane Yapay zeka ve Teknoloji kitapları üzerine konuştuğumuz videolar çekiyoruz. Bu videolarda alanında uzman diğer arkadaşlarımı da konuk alıp videolar hazırlıyoruz. Gül Bulut ile Ethem Hocanın kitabını birlikte yorumlama şansına sahip olduk (bir kitaba daha hazırlanıyoruz). Şefik ilkin Serengil ve Semih Arıcan ile de çok yakında videolarımızı çekmiş olacağız.

Biz kimiz ve videoları neden çekiyoruz?

Videoların amatörlüğünün farkındayız zaten amacımız YouTuber olmak değil ve daha önce herkese açık bir ortamda veya kameralar önünde konuşmadık (ama gittikçe iyileşiyoruz :) ). Sadece Yapay zeka alanına olan ilgimizden okuduğumuz kitapların bizim için anlamlı bölümleri üzerine konuşuyoruz. İzleyenlere sadece bu alanla ilgili olan kitapların listelendiğini görmeleri ve kitapta aşağı yukarı nelerden bahsedildiğini öğrenmeleri bizim için yeterli olacaktır. Şimdi biz kimiz biraz bundan bahsedelim çünkü videoların başında artık kendimizden bahsetmiyoruz.

İlker Aytı, Yeditepe Üniversitesi Bilgisayar mühendisliği bölümünden mezun. 9 yıllı aşkın süredir profesyonel hayatta çalışmaktadır. Papara, Türk Traktör, Procter & Gamble, Borusan, RE/MAX, Philip Morris International gibi firmalar için cloud native mikro servis tabanlı uygulamalar (Backend ağırlıklı) üzerine geliştirmeler yapıyorken son 3 yıldır Yapay Zeka ve Derin öğrenme alanında da çalışmalar yürütmektedir.

Gül bulut, 2013 yılında Uludağ Elektronik bölümünden mezun oldu. ilk 2 yıl savunma sanayi işbirlikleri ve Tübitak projeleri üzerine çalıştı. 2015 yılı itibariyle İTÜ Bilişim enstitüsünde Uydu haberleşmesi ve Uzaktan Algılama bölümünde Yüksek Lisansa başladı. Kariyer hayatında da o yıldan itibaren Softtech'te devam ettirmektedir. Çeşitli projelerde yazılım yaşam döngüsünde roller değiştirerek bu döngünün içinde bulundu. Softtech-Aircar işbirliğinde, Aircar projelerinde çalışmalarına devam etmektedir.

Ben Bülent Siyah, ben de 2012 yılında Bilgisayar mühendisliği bölümünden mezun oldum. ilk 5 yıl Android ve IOS işletim sistemleri için uygulama geliştirdim. 2017 den beri Softtech isimli bir şirkette Yapay zeka alanında çalışıyorum. Son 2 yıldır da Aircar isimli uçan araba geliştiren bir şirkette çalışıyorum (Softtech-Aircar işbirliğinden dolayı 2 şirkette projeler geliştiriyorum). İnsansız Hava Araçlarında (veya büyük Dronelar) kullanılmak üzere Derin Öğrenme ve Bilgisayarlı Görü projeleri üzerine çalışıyorum. Çalışmalarım Acil İniş Yeri Tanımlama Sistemi, Havada Tehdit Algılama ve Kaçış Sistemi, Otonom Port İnişine Rehberlik, GPS kesintisi Durumuna Karşı Görüye Dayalı Navigasyon Sistemi geliştirmek.

İncelediğimiz Kitaplar

Öncelikle liste sürekli yenilendiği için ben oynatma listesinin linkini paylaşıyım. Yapay Zeka ve Teknoloji Üzerine Kitap İncelemeleri Youtube Linki

Şimdi sırayla inceleme videolarını paylaşıyım.

#9 - Yapay Öğrenme: Yeni Yapay Zeka (Ethem ALPAYDIN) - Kitap İnceleme

#8 - Yapay Zeka ve Gelecek (Editör: Prof. Dr. Gonca Telli) - Kitap İnceleme

#7 - Bilincin Gizemi (John R. Searle) - Kitap İnceleme

#6 - Dijital Dönüşüm-Yapay Zeka (Harvard Business Review) - Kitap İnceleme

#5 - Yeni Dünya Yeni Ağ (Cem Say) - Kitap İnceleme

#4 - Ben Robot (ISAAC ASIMOV) - Kitap İnceleme

#3 - Robotların Yükselişi: Yapay Zeka ve İşsiz Bir Gelecek Tehlikesi (Martin Ford) - Kitap İnceleme

Yapay Öğrenme: Yeni Yapay Zeka (Ethem ALPAYDIN) - Kitap İnceleme

#2 - 50 Soruda Yapay Zeka (Cem Say) - Kitap İnceleme

#1 - Python ile Derin Öğrenme (François Chollet) - Kitap İnceleme

►►Kitap İncelemesini Yapanların kişisel blog ve hesapları

► İlker Aytı

• https://www.ilkerayti.com
• LinkedIn: https://www.linkedin.com/in/ilkerayti
• Github: https://github.com/iayti​​
• Kaggle: https://www.kaggle.com/ilkerayti​​

►Gül Bulut

• LinkedIn: https://www.linkedin.com/in/fgulyvz
• Github: https://github.com/gulbulut​
• Kaggle: https://www.kaggle.com/gulyvz

►Bülent Siyah

• https://www.bulentsiyah.com​​
• LinkedIn: https://www.linkedin.com/in/bulentsiyah
• Github: https://github.com/bulentsiyah​​
• Kaggle: https://www.kaggle.com/bulentsiyah

Very great summary of Lex Fridman

Tesla Bot: A definitely real humanoid robot

When Tesla talks about using its advanced technology in applications outside of cars, we didn’t think he was talking about robot slaves. That’s not an exaggeration. CEO Elon Musk envisions a world in which the human drudgery like grocery shopping, “the work that people least like to do,” can be taken over by humanoid robots like the Tesla Bot. The bot is 5’8″, 125 pounds, can deadlift 150 pounds, walk at 5 miles per hour and has a screen for a head that displays important information.

“It’s intended to be friendly, of course, and navigate a world built for humans,” said Musk. “We’re setting it such that at a mechanical and physical level, you can run away from it and most likely overpower it.”

Because everyone is definitely afraid of getting beat up by a robot that’s truly had enough, right?

The bot, a prototype of which is expected for next year, is being proposed as a non-automotive robotic use case for the company’s work on neural networks and its Dojo advanced supercomputer.

D1 Chip: Unveiling of the chip to train Dojo

Tesla director Ganesh Venkataramanan unveiled Tesla’s computer chip, designed and built entirely in-house, that the company is using to run its supercomputer, Dojo. Much of Tesla’s AI architecture is dependent on Dojo, the neural network training computer that Musk says will be able to process vast amounts of camera imaging data four times faster than other computing systems. The idea is that the Dojo-trained AI software will be pushed out to Tesla customers via over-the-air updates.

The chip that Tesla revealed on Thursday is called “D1,” and it contains a 7 nm technology. Venkataramanan proudly held up the chip that he said has GPU-level compute with CPU connectivity and twice the I/O bandwidth of “the state of the art networking switch chips that are out there today and are supposed to be the gold standards.” He walked through the technicalities of the chip, explaining that Tesla wanted to own as much of its tech stack as possible to avoid any bottlenecks.

Aside from limited availability, the overall goal of taking the chip production in-house is to increase bandwidth and decrease latencies for better AI performance.

“We can do compute and data transfers simultaneously, and our custom ISA, which is the instruction set architecture, is fully optimized for machine learning workloads,” said Venkataramanan at AI Day. “This is a pure machine learning machine.”

Venkataramanan also revealed a “training tile” that integrates multiple chips to get higher bandwidth and an incredible computing power of 9 petaflops per tile and 36 terabytes per second of bandwidth. Together, the training tiles compose the Dojo supercomputer.

Supercomputer Dojo : To Full Self-Driving and beyond

Many of the speakers at the AI Day event noted that Dojo will not just be a tech for Tesla’s “Full Self-Driving” (FSD) system, it’s definitely impressive advanced driver assistance system that’s also definitely not yet fully self-driving or autonomous. The powerful supercomputer is built with multiple aspects, such as the simulation architecture, that the company hopes to expand to be universal and even open up to other automakers and tech companies.

“This is not intended to be just limited to Tesla cars,” said Musk. “Those of you who’ve seen the full self-driving beta can appreciate the rate at which the Tesla neural net is learning to drive. And this is a particular application of AI, but I think there’s more applications down the road that will make sense.”

Musk said Dojo is expected to be operational next year, at which point we can expect talk about how this tech can be applied to many other use cases.

Solving computer vision problems

Tesla’s head of AI, Andrej Karpathy, described Tesla’s architecture as “building an animal from the ground up” that moves around, senses its environment and acts intelligently and autonomously based on what it sees.

Karpathy illustrated how Tesla’s neural networks have developed over time, and how now, the visual cortex of the car, which is essentially the first part of the car’s “brain” that processes visual information, is designed in tandem with the broader neural network architecture so that information flows into the system more intelligently.

The two main problems that Tesla is working on solving with its computer vision architecture are temporary occlusions (like cars at a busy intersection blocking Autopilot’s view of the road beyond) and signs or markings that appear earlier in the road (like if a sign 100 meters back says the lanes will merge, the computer once upon a time had trouble remembering that by the time it made it to the merge lanes).

To solve for this, Tesla engineers fell back on a spatial recurring network video module, wherein different aspects of the module keep track of different aspects of the road and form a space-based and time-based queue, both of which create a cache of data that the model can refer back to when trying to make predictions about the road.

The company flexed its over 1,000-person manual data labeling team and walked the audience through how Tesla auto-labels certain clips, many of which are pulled from Tesla’s fleet on the road, in order to be able to label at scale. With all of this real-world info, the AI team then uses incredible simulation, creating “a video game with Autopilot as the player.” The simulations help particularly with data that’s difficult to source or label, or if it’s in a closed loop.

“We basically want to encourage anyone who is interested in solving real-world AI problems at either the hardware or the software level to join Tesla, or consider joining Tesla,” said Musk.

All broadcast

Referanslar: [https://techcrunch.com/2021/08/19/top-five-highlights-of-elon-musks-tesla-ai-day/] (https://techcrunch.com/2021/08/19/top-five-highlights-of-elon-musks-tesla-ai-day/)

https://electrek.co/2021/08/20/tesla-dojo-supercomputer-worlds-new-most-powerful-ai-training-machine/

https://electrek.co/2021/08/19/tesla-bot-humanoid-robot/

https://dronedj.com/2021/08/20/elon-musk-tesla-bot/

https://electrek.co/2021/06/21/elon-musk-tesla-ai-day-progress-recruit-talent/

The term “artificial intelligence” is coined in a proposal for a “2 month, 10 man study of artificial intelligence” submitted by John McCarthy (Dartmouth College), Marvin Minsky (Harvard University), Nathaniel Rochester (IBM), and Claude Shannon (Bell Telephone Laboratories). The workshop, which took place a year later, in July and August 1956, is generally considered as the official birthdate of the new field. Most of us know this, but in a book I read, I learned that there was a letter with the first word "artificial intelligence". This letter was written by John McCarthy while requesting funding from the Rockefeller Foundation. This got me very excited and for those who are curious about the rest of the letter, "Proposal for the Dartmouth summer research project on artificial intelligence" PDF download

Proposal for the Dartmouth summer research project on artificial intelligence

Dartmouth workshop

The Dartmouth Summer Research Project on Artificial Intelligence was a 1956 summer workshop widely considered to be the founding event of artificial intelligence as a field.

The project lasted approximately six to eight weeks and was essentially an extended brainstorming session. Eleven mathematicians and scientists originally planned to attend; not all of them attended, but more than ten others came for short times.

###Background In 1955, John McCarthy, then a young Assistant Professor of Mathematics at Dartmouth College, decided to organize a group to clarify and develop ideas about thinking machines. He picked the name 'Artificial Intelligence' for the new field.

In early 1955, McCarthy approached the Rockefeller Foundation to request funding for a summer seminar at Dartmouth for about 10 participants. In June, he and Claude Shannon, a founder of information theory then at Bell Labs, met with Robert Morison, Director of Biological and Medical Research to discuss the idea and possible funding, though Morison was unsure whether money would be made available for such a visionary project.

On September 2, 1955, the project was formally proposed by McCarthy, Marvin Minsky, Nathaniel Rochester and Claude Shannon. The proposal is credited with introducing the term 'artificial intelligence'.

###The Proposal states We propose that a 2-month, 10-man study of artificial intelligence be carried out during the summer of 1956 at Dartmouth College in Hanover, New Hampshire. The study is to proceed on the basis of the conjecture that every aspect of learning or any other feature of intelligence can in principle be so precisely described that a machine can be made to simulate it. An attempt will be made to find how to make machines use language, form abstractions and concepts, solve kinds of problems now reserved for humans, and improve themselves. We think that a significant advance can be made in one or more of these problems if a carefully selected group of scientists work on it together for a summer.

The proposal goes on to discuss computers, natural language processing, neural networks, theory of computation, abstraction and creativity (these areas within the field of artificial intelligence are considered still relevant to the work of the field).

###Dates The Dartmouth Workshop is said to have run for six weeks in the summer of 1956. Ray Solomonoff's notes written during the Workshop, however, say it ran for roughly eight weeks, from about June 18 to August 17. Solomonoff's Dartmouth notes start on June 22; June 28 mentions Minsky, June 30 mentions Hanover, N.H., July 1 mentions Tom Etter. On August 17, Ray gave a final talk.

###Event and aftermath Did they reach their goals in those 2 months? I mean, the 10 best researchers in the field were under one roof. They must have found something.

They failed to do what they intended, and no projects were launched. McCarthy explains three reasons for his failure: First, the Rockefeller Foundation only gave them half of the money they wanted. Second, and that's the main reason, all of the participants had their own research agenda and didn't get very far from them. Third: Participants came to Dartmouth at different times and at different times.

###The Next Fifty Years Trenchard More, John McCarthy, Marvin Minsky, Oliver Selfridge, and Ray Solomonoff

Sources: https://en.wikipedia.org/wiki/Dartmouth_workshop https://ichi.pro/tr/dartmouth-workshop-yapay-zekanin-dogdugu-yer-58021580368274 https://www.researchgate.net/journal/Ai-Magazine-0738-4602 http://www-formal.stanford.edu/jmc/slides/dartmouth/dartmouth/node1.html http://raysolomonoff.com/dartmouth/boxa/dart56more5th6thweeks.pdf http://raysolomonoff.com/dartmouth/dartray.pdf https://medium.com/@pemey/whos-that-kid-laughing-with-high-socks-in-the-middle-of-summer-7801a34feeef https://www.cantorsparadise.com/the-birthplace-of-ai-9ab7d4e5fb00 https://chsasank.github.io/classic_papers/darthmouth-artifical-intelligence-summer-resarch-proposal.html https://www.researchgate.net/publication/220494500_Cybernetics_Automata_Studies_and_the_Dartmouth_Conference_on_Artificial_Intelligence https://rockfound.rockarch.org/digital-library-listing/-/asset_publisher/yYxpQfeI4W8N/content/letter-from-robert-s-morison-to-john-mccarthy-1955-november-30

This study is an example for a simple computer vision. In the study, the coordinate point is based on calculating the coordinate information of another point on the picture by referring to a known place.

The only information required is to know what the centimeter equivalent of a pixel is on the picture.

import cv2 
import matplotlib
import matplotlib.pyplot as plt
from utils import PixelLocation
from gpsupdater import GPSUpdater 
from geocalculation import GeoCalculation

def main():
    image = "src/istanbul_aerial_1pixel_10_centimeters.png"

    image = cv2.imread(image, 1)
    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

    height, width = image.shape[:2]
    print(width, height, "width, height")
    ratio_pixel_centimeters = 10

    selected_position = PixelLocation(
        label="GPS location known place",
        x_pixel=int(width / 2) ,
        y_pixel=480,
        latitude=28.971832514674194,
        longitude= 41.01209534207387,
    )

    calculation_position = PixelLocation(
        label="GPS location, location to be calculated",
        x_pixel=int(width / 2) + 1000, # 1000 / ratio_pixel_centimeters =  100 meters east
        y_pixel=480 + 2000, # 2000 / ratio_pixel_centimeters = 200 meters south
        latitude=0.0,
        longitude= 0.0,
    )


    print('selected_position x:{0}, y:{1}, calculation_position x:{2}, y:{3}'.format(selected_position.x_pixel,
    selected_position.y_pixel, 
    calculation_position.x_pixel,
    calculation_position.y_pixel))

    text_selected = 'selected_position latitude:{0:.7f}, longitude:{1:.7f}, '.format(selected_position.latitude,
    selected_position.longitude)
    print(text_selected)

    distance, bearing = GPSUpdater.distance_bearing_calculator_using_parameters(destination_x=calculation_position.x_pixel,
                                                                                     destination_y=calculation_position.y_pixel,
                                                                                    source_x=selected_position.x_pixel,
                                                                                    source_y=selected_position.y_pixel,
                                                                                    image_height=height,
                                                                                    pixel_in_centimeters=ratio_pixel_centimeters)

    print('distance:{0} bearing:{1}'.format(distance,bearing))

    calculation_position.latitude, calculation_position.longitude = GeoCalculation.calculate_new_gps_position(lat1=selected_position.latitude,
    lon1=selected_position.longitude,distance=distance,bearing=bearing)


    text_calculation = 'calculation_position latitude:{0:.7f}, longitude:{1:.7f}'.format(calculation_position.latitude,calculation_position.longitude)
    print(text_calculation)


    start_point = (selected_position.x_pixel, selected_position.y_pixel)
    end_point = (calculation_position.x_pixel, calculation_position.y_pixel )

    thickness = 10
    color = (255, 0, 0) 
    image = cv2.line(image, start_point, end_point, color, thickness)


    org_y = 200
    org_x = 10
    org = (org_x, org_y) # x:column y:row 
    font = cv2.FONT_HERSHEY_SIMPLEX
    fontScale = 3
    color = (255, 255, 0) 
    paddingText = 50

    cv2.putText(image, text_selected, org, font, fontScale, color, thickness, cv2.LINE_AA) 

    org_y = org_y+3*paddingText+thickness
    org_x = 10
    org = (org_x, org_y)
    cv2.putText(image,text_calculation , org, font, fontScale, color, thickness, cv2.LINE_AA)

    org_y = org_y+3*paddingText+thickness
    org_x = 10
    org = (org_x, org_y)
    cv2.putText(image,'different distance:{0:.2f} meters'.format(distance) , org, font, fontScale, color, thickness, cv2.LINE_AA)



    plt.figure(figsize=(10, 10))
    plt.imshow(image)
    plt.show()


if __name__ == '__main__':
    main()

The first step in training our segmentation model is to prepare the dataset. We would need the input RGB images and the corresponding segmentation images. If you want to make your own dataset, a tool like labelme or GIMP can be used to manually generate the ground truth segmentation masks. Assign each class a unique ID. In the segmentation images, the pixel value should denote the class ID of the corresponding pixel. You can examine for Deep Learning based Semantic Segmentation example

If you have RGB color image masks (like Aerial Semantic Segmentation Drone Dataset RGB_color_masks Folder ) , you can follow the steps below. First of all, our goal is to obtain a pixel-based class image from RGB color image masks as follows.RGB color image maskspixel-based class image masks

The dataset has RGB colored segmentation masks, and there are 24 classes in the dataset. The dataset has a file named class_dict.csv and it contains the name of the classes and their respective RGB values. The contents of the file are as follows:

import os,re
from PIL import Image
import numpy as np
import pandas as pd
import cv2
import matplotlib.pyplot as plt
%matplotlib inline

def atoi(text) : 
    return int(text) if text.isdigit() else text

def natural_keys(text) :
    return [atoi(c) for c in re.split('(\d+)', text)]


read_csv = pd.read_csv('/kaggle/input/semantic-drone-dataset/class_dict_seg.csv',index_col=False,skipinitialspace=True)
read_csv.head()

def segmantation_images(path,new_path, debug_test_num):
    filenames = []

    for root, dirnames, filenames in os.walk(path):
        filenames.sort(key = natural_keys)
        rootpath = root

    #print(filenames)
    count = 0
    for item in filenames:

        if debug_test_num !=0:
            if debug_test_num <= count:
                break

        count = count + 1

        if os.path.isfile(path+item):
            f, e = os.path.splitext(item)
            image_rgb = Image.open(path+item)
            image_rgb = np.asarray(image_rgb)
            new_image = np.zeros((image_rgb.shape[0],image_rgb.shape[1],3)).astype('int')

            for index, row  in read_csv.iterrows():
                new_image[(image_rgb[:,:,0]==row.r)&
                          (image_rgb[:,:,1]==row.g)&
                          (image_rgb[:,:,2]==row.b)]=np.array([index+1,index+1,index+1]).reshape(1,3)

            new_image = new_image[:,:,0]
            output_filename = new_path+f+'.png'
            cv2.imwrite(output_filename,new_image)
            print('writing file: ',output_filename)

        else:
            print('no file')

    print("number of files written: ",count)

debug_test_num = 5 # 5 samples are enough just to see it working. If you set 0, you can do all the datasets.
segmantation_images("/kaggle/input/semantic-drone-dataset/RGB_color_image_masks/RGB_color_image_masks/", "", debug_test_num=debug_test_num)

from PIL import Image
input_image = "/kaggle/input/semantic-drone-dataset/RGB_color_image_masks/RGB_color_image_masks/"+"002.png"
output_image = "002.png"

fig, axs = plt.subplots(1, 2, figsize=(16, 8), constrained_layout=True)

img_orig = Image.open(input_image)
axs[0].imshow(img_orig)
axs[0].grid(False)

output_image = Image.open(output_image)
out_array = np.asarray(output_image)
axs[1].imshow(out_array)
axs[1].grid(False)

In this post, you will discover the ImageNet dataset, the ILSVRC, and the key milestones in image classification that have resulted from the competitions. This post has been prepared by making use of all the references below. > This slide from the ImageNet team shows the winning team's error rate each year in the top-5 classification task. The error rate fell steadily from 2010 to 2017

ImageNet Dataset

ImageNet is a dataset of over 15 million labeled high-resolution images belonging to roughly 22,000 categories. The images were collected from the web and labeled by human labelers using Amazon’s Mechanical Turk crowd-sourcing tool. Starting in 2010, as part of the Pascal Visual Object Challenge, an annual competition called the ImageNet Large-Scale Visual Recognition Challenge (ILSVRC) has been held. ILSVRC uses a subset of ImageNet with roughly 1000 images in each of 1000 categories. In all, there are roughly 1.2 million training images, 50,000 validation images, and 150,000 testing images.

On ImageNet, it is customary to report two error rates: top-1 and top-5, where the top-5 error rate is the fraction of test images for which the correct label is not among the five labels considered most probable by the model. ImageNet consists of variable-resolution images, while our system requires a constant input dimensionality.

ImageNet Large Scale Visual Recognition Challenge (ILSVRC)

The general challenge tasks for most years are as follows:

• Image classification: Predict the classes of objects present in an image.
• Single-object localization: Image classification + draw a bounding box around one example of each object present.
• Object detection: Image classification + draw a bounding box around each object present.

> Summary of the Improvement on ILSVRC Tasks Over the First Five Years of the Competition. Taken from ImageNet Large Scale Visual Recognition Challenge, 2015

Deep Learning Milestones From ILSVRC

The pace of improvement in the first five years of the ILSVRC was dramatic, perhaps even shocking to the field of computer vision. Success has primarily been achieved by large (deep) convolutional neural networks (CNNs) on graphical processing unit (GPU) hardware, which sparked an interest in deep learning that extended beyond the field out into the mainstream.

ILSVRC-2012

AlexNet (SuperVision)

On 30 September 2012, a convolutional neural network (CNN) called AlexNet achieved a top-5 error of 15.3% in the ImageNet 2012 Challenge, more than 10.8 percentage points lower than that of the runner up. This was made feasible due to the use of Graphics processing units (GPUs) during training, an essential ingredient of the deep learning revolution. According to The Economist, "Suddenly people started to pay attention, not just within the AI community but across the technology industry as a whole.

• ImageNet Classification with Deep Convolutional Neural Networks, 2012. (Authors: Alex Krizhevsky, Ilya Sutskever, Geoffrey Hinton. University of Toronto, Canada.)
• With 60M parameters, AlexNet has 8 layers — 5 convolutional and 3 fully-connected.
• They were the first to implement Rectified Linear Units (ReLUs) as activation functions.

ILSVRC-2013

ZFNet (Clarifai)

Matthew Zeiler and Rob Fergus propose a variation of AlexNet generally referred to as ZFNet in their 2013 paper titled “Visualizing and Understanding Convolutional Networks,” a variation of which won the ILSVRC-2013 image classification task.

ILSVRC-2014

Inception (GoogLeNet)

Christian Szegedy, et al. from Google achieved top results for object detection with their GoogLeNet model that made use of the inception module and architecture. This approach was described in their 2014 paper titled “Going Deeper with Convolutions.” Introduced the Inception Module, which emphasized that the layers of a CNN doesn't always have to be stacked up sequentially. The winner of ILSVRC 2014 with an error rate of 6.7%.

VGG

Karen Simonyan and Andrew Zisserman from the Oxford Vision Geometry Group (VGG) achieved top results for image classification and localization with their VGG model. Their approach is described in their 2015 paper titled “Very Deep Convolutional Networks for Large-Scale Image Recognition.”. The folks at Visual Geometry Group (VGG) invented the VGG-16 which has 13 convolutional and 3 fully-connected layers, carrying with them the ReLU tradition from AlexNet. This network stacks more layers onto AlexNet, and use smaller size filters (2×2 and 3×3). It consists of 138M parameters and takes up about 500MB of storage space They also designed a deeper variant, VGG-19.

ILSVRC-2015

ResNet (MSRA)

Kaiming He, et al. from Microsoft Research achieved top results for object detection and object detection with localization tasks with their Residual Network or ResNet described in their 2015 paper titled “Deep Residual Learning for Image Recognition.” An ensemble of these residual nets achieves 3.57% error on the ImageNet test set. Ultra-deep (quoting the authors) architecture with 152 layers. Introduced the Residual Block, to reduce overfitting

ILSVRC-2016

ResNeXt

The model name, ResNeXt, contains Next. It means the next dimension, on top of the ResNet. This next dimension is called the “cardinality” dimension. And ResNeXt becomes the 1st Runner Up of ILSVRC classification task.

ILSVRC-2017

SENet

With “Squeeze-and-Excitation” (SE) block that adaptively recalibrates channel-wise feature responses by explicitly modelling interdependencies between channels, SENet is constructed. And it won the first place in ILSVRC 2017 classification challenge with top-5 error to 2.251% which has about 25% relative improvement over the winning entry of 2016. And this is a paper in 2018 CVPR with more than 600 citations. Recently, it is also published in 2019 TPAMI.

Thank you so much if you have read so far. I have always wondered how ImageNet is progressing. I hope it benefits everyone who reads.

References:

• http://www.cs.toronto.edu/~hinton/absps/imagenet.pdf
• https://machinelearningmastery.com/introduction-to-the-imagenet-large-scale-visual-recognition-challenge-ilsvrc/
• https://arxiv.org/pdf/1409.0575.pdf
• http://image-net.org/challenges/LSVRC/2017/index
• https://en.wikipedia.org/wiki/ImageNet
• https://towardsdatascience.com/illustrated-10-cnn-architectures-95d78ace614d
• https://www.codesofinterest.com/2017/07/milestones-of-deep-learning.html
• http://image-net.org/challenges/LSVRC/2016/results
• https://towardsdatascience.com/review-trimps-soushen-winner-in-ilsvrc-2016-image-classification-dfbc423111dd
• https://towardsdatascience.com/review-resnext-1st-runner-up-of-ilsvrc-2016-image-classification-15d7f17b42ac
• http://image-net.org/challenges/LSVRC/2017/results
• https://towardsdatascience.com/review-senet-squeeze-and-excitation-network-winner-of-ilsvrc-2017-image-classification-a887b98b2883
• https://medium.com/coinmonks/paper-review-of-alexnet-caffenet-winner-in-ilsvrc-2012-image-classification-b93598314160
• https://mc.ai/paper-review-of-zfnet-the-winner-of-ilsvlc-2013-image-classification/
• http://image-net.org/challenges/talks_2017/imagenet_ilsvrc2017_v1.0.pdf
• https://iq.opengenus.org/evolution-of-cnn-architectures/

This work was prepared together with Gul Bulut and Bulent Siyah. The whole study consists of two parties

• Time Series Forecasting and Analysis- Part 1
• Time Series Forecasting and Analysis- Part 2

This kernel will teach you everything you need to know to use Python for forecasting time series data to predict new future data points.

we'll learn about state of the art Deep Learning techniques with Recurrent Neural Networks that use deep learning to forecast future data points.

This kernel even covers Facebook's Prophet library, a simple to use, yet powerful Python library developed to forecast into the future with time series data.

Content Part 1

1. How to Work with Time Series Data with Pandas
2. Use Statsmodels to Analyze Time Series Data
3. General Forecasting Models - ARIMA(Autoregressive Integrated Moving Average)
4. General Forecasting Models - SARIMA(Seasonal Autoregressive Integrated Moving Average)
5. General Forecasting Models - SARIMAX

Content Part 2

1. Deep Learning for Time Series Forecasting - (RNN)
2. Multivariate Time Series with RNN
3. Use Facebook's Prophet Library for forecasting

)

In [1]:

import pandas as pd import numpy as np %matplotlib inline import matplotlib.pyplot as plt 

In [2]:

df = pd.read_csv('/kaggle/input/for-simple-exercises-time-series-forecasting/Alcohol_Sales.csv',index_col='DATE',parse_dates=True) df.index.freq = 'MS' df.head() 

Out[2]:

S4248SM144NCEN

DATE

1992-01-013459

1992-02-013458

1992-03-014002

1992-04-014564

1992-05-014221

In [3]:

df.columns = ['Sales'] df.plot(figsize=(12,8)) 

Out[3]:

<matplotlib.axes._subplots.AxesSubplot at 0x7f708742e048>

In [4]:

from statsmodels.tsa.seasonal import seasonal_decompose results = seasonal_decompose(df['Sales']) results.observed.plot(figsize=(12,2)) 

Out[4]:

<matplotlib.axes._subplots.AxesSubplot at 0x7f70751227f0>

In [5]:

results.trend.plot(figsize=(12,2)) 

Out[5]:

<matplotlib.axes._subplots.AxesSubplot at 0x7f7074e84550>

In [6]:

results.seasonal.plot(figsize=(12,2)) 

Out[6]:

<matplotlib.axes._subplots.AxesSubplot at 0x7f7074da3f28>

In [7]:

results.resid.plot(figsize=(12,2)) 

Out[7]:

<matplotlib.axes._subplots.AxesSubplot at 0x7f7074d3a390>

Train Test Split

In [8]:

print("len(df)", len(df)) train = df.iloc[:313] test = df.iloc[313:] print("len(train)", len(train)) print("len(test)", len(test)) 

len(df) 325 len(train) 313 len(test) 12 

Scale Data

In [9]:

from sklearn.preprocessing import MinMaxScaler scaler = MinMaxScaler() # IGNORE WARNING ITS JUST CONVERTING TO FLOATS # WE ONLY FIT TO TRAININ DATA, OTHERWISE WE ARE CHEATING ASSUMING INFO ABOUT TEST SET scaler.fit(train) 

Out[9]:

MinMaxScaler(copy=True, feature_range=(0, 1))

In [10]:

scaled_train = scaler.transform(train) scaled_test = scaler.transform(test) 

Time Series Generator

This class takes in a sequence of data-points gathered at equal intervals, along with time series parameters such as stride, length of history, etc., to produce batches for training/validation.

In [11]:

from keras.preprocessing.sequence import TimeseriesGenerator scaled_train[0] 

Using TensorFlow backend. 

Out[11]:

array([0.03658432])

In [12]:

# define generator n_input = 2 n_features = 1 generator = TimeseriesGenerator(scaled_train, scaled_train, length=n_input, batch_size=1) print('len(scaled_train)',len(scaled_train)) print('len(generator)',len(generator)) # n_input = 2 

len(scaled_train) 313 len(generator) 311 

In [13]:

# What does the first batch look like? X,y = generator[0] print(f'Given the Array: \n{X.flatten()}') print(f'Predict this y: \n{y}') 

Given the Array: [0.03658432 0.03649885] Predict this y: [[0.08299855]] 

In [14]:

# Let's redefine to get 12 months back and then predict the next month out n_input = 12 generator = TimeseriesGenerator(scaled_train, scaled_train, length=n_input, batch_size=1) # What does the first batch look like? X,y = generator[0] print(f'Given the Array: \n{X.flatten()}') print(f'Predict this y: \n{y}') 

Given the Array: [0.03658432 0.03649885 0.08299855 0.13103684 0.1017181 0.12804513 0.12266006 0.09453799 0.09359774 0.10496624 0.10334217 0.16283443] Predict this y: [[0.]] 

Create the Model

In [15]:

from keras.models import Sequential from keras.layers import Dense from keras.layers import LSTM # define model model = Sequential() model.add(LSTM(100, activation='relu', input_shape=(n_input, n_features))) model.add(Dense(1)) model.compile(optimizer='adam', loss='mse') model.summary() 

Model: "sequential_1" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= lstm_1 (LSTM) (None, 100) 40800 _________________________________________________________________ dense_1 (Dense) (None, 1) 101 ================================================================= Total params: 40,901 Trainable params: 40,901 Non-trainable params: 0 _________________________________________________________________ 

In [16]:

# fit model model.fit_generator(generator,epochs=50) 

Epoch 1/50 301/301 [==============================] - 2s 7ms/step - loss: 0.0170 Epoch 2/50 301/301 [==============================] - 2s 5ms/step - loss: 0.0085 Epoch 3/50 301/301 [==============================] - 2s 5ms/step - loss: 0.0088 Epoch 4/50 301/301 [==============================] - 2s 5ms/step - loss: 0.0072 Epoch 5/50 301/301 [==============================] - 2s 5ms/step - loss: 0.0061 Epoch 6/50 301/301 [==============================] - 2s 6ms/step - loss: 0.0050 Epoch 7/50 301/301 [==============================] - 2s 5ms/step - loss: 0.0043 Epoch 8/50 301/301 [==============================] - 2s 5ms/step - loss: 0.0036 Epoch 9/50 301/301 [==============================] - 2s 5ms/step - loss: 0.0030 Epoch 10/50 301/301 [==============================] - 2s 5ms/step - loss: 0.0026 Epoch 11/50 301/301 [==============================] - 2s 5ms/step - loss: 0.0021 Epoch 12/50 301/301 [==============================] - 2s 5ms/step - loss: 0.0021 Epoch 13/50 301/301 [==============================] - 2s 6ms/step - loss: 0.0019 Epoch 14/50 301/301 [==============================] - 2s 6ms/step - loss: 0.0019 Epoch 15/50 301/301 [==============================] - 2s 6ms/step - loss: 0.0020 Epoch 16/50 301/301 [==============================] - 2s 6ms/step - loss: 0.0020 Epoch 17/50 301/301 [==============================] - 2s 6ms/step - loss: 0.0016 Epoch 18/50 301/301 [==============================] - 2s 6ms/step - loss: 0.0017 Epoch 19/50 301/301 [==============================] - 2s 6ms/step - loss: 0.0014 Epoch 20/50 301/301 [==============================] - 2s 5ms/step - loss: 0.0016 Epoch 21/50 301/301 [==============================] - 2s 6ms/step - loss: 0.0017 Epoch 22/50 301/301 [==============================] - 2s 6ms/step - loss: 0.0016 Epoch 23/50 301/301 [==============================] - 2s 5ms/step - loss: 0.0016 Epoch 24/50 301/301 [==============================] - 2s 6ms/step - loss: 0.0015 Epoch 25/50 301/301 [==============================] - 2s 5ms/step - loss: 0.0015 Epoch 26/50 301/301 [==============================] - 2s 6ms/step - loss: 0.0015 Epoch 27/50 301/301 [==============================] - 2s 6ms/step - loss: 0.0017 Epoch 28/50 301/301 [==============================] - 2s 6ms/step - loss: 0.0015 Epoch 29/50 301/301 [==============================] - 2s 6ms/step - loss: 0.0013 Epoch 30/50 301/301 [==============================] - 2s 6ms/step - loss: 0.0015 Epoch 31/50 301/301 [==============================] - 2s 6ms/step - loss: 0.0015 Epoch 32/50 301/301 [==============================] - 2s 6ms/step - loss: 0.0014 Epoch 33/50 301/301 [==============================] - 2s 6ms/step - loss: 0.0014 Epoch 34/50 301/301 [==============================] - 2s 6ms/step - loss: 0.0013 Epoch 35/50 301/301 [==============================] - 2s 6ms/step - loss: 0.0016 Epoch 36/50 301/301 [==============================] - 2s 5ms/step - loss: 0.0016 Epoch 37/50 301/301 [==============================] - 2s 6ms/step - loss: 0.0014 Epoch 38/50 301/301 [==============================] - 2s 6ms/step - loss: 0.0014 Epoch 39/50 301/301 [==============================] - 2s 6ms/step - loss: 0.0014 Epoch 40/50 301/301 [==============================] - 2s 6ms/step - loss: 0.0015 Epoch 41/50 301/301 [==============================] - 2s 6ms/step - loss: 0.0013 Epoch 42/50 301/301 [==============================] - 2s 6ms/step - loss: 0.0015 Epoch 43/50 301/301 [==============================] - 2s 6ms/step - loss: 0.0013 Epoch 44/50 301/301 [==============================] - 2s 6ms/step - loss: 0.0013 Epoch 45/50 301/301 [==============================] - 2s 6ms/step - loss: 0.0012 Epoch 46/50 301/301 [==============================] - 2s 6ms/step - loss: 0.0012 Epoch 47/50 301/301 [==============================] - 2s 6ms/step - loss: 0.0012 Epoch 48/50 301/301 [==============================] - 2s 6ms/step - loss: 0.0014 Epoch 49/50 301/301 [==============================] - 2s 6ms/step - loss: 0.0013 Epoch 50/50 301/301 [==============================] - 2s 6ms/step - loss: 0.0013 

Out[16]:

<keras.callbacks.callbacks.History at 0x7f706053e4a8>

In [17]:

model.history.history.keys() loss_per_epoch = model.history.history['loss'] plt.plot(range(len(loss_per_epoch)),loss_per_epoch) 

Out[17]:

[<matplotlib.lines.Line2D at 0x7f705863f7f0>]

Evaluate on Test Data

In [18]:

first_eval_batch = scaled_train[-12:] first_eval_batch 

Out[18]:

array([[0.63432772], [0.80776135], [0.72313873], [0.89870929], [1. ], [0.71672793], [0.88648602], [0.75869732], [0.82742115], [0.87443371], [0.96025301], [0.5584238 ]])

In [19]:

first_eval_batch = first_eval_batch.reshape((1, n_input, n_features)) model.predict(first_eval_batch) 

Out[19]:

array([[0.6874868]], dtype=float32)

In [20]:

scaled_test[0] 

Out[20]:

array([0.63116506])

In [21]:

test_predictions = [] first_eval_batch = scaled_train[-n_input:] current_batch = first_eval_batch.reshape((1, n_input, n_features)) for i in range(len(test)): # get prediction 1 time stamp ahead ([0] is for grabbing just the number instead of [array]) current_pred = model.predict(current_batch)[0] # store prediction test_predictions.append(current_pred) # update batch to now include prediction and drop first value current_batch = np.append(current_batch[:,1:,:],[[current_pred]],axis=1) test_predictions 

Out[21]:

[array([0.6874868], dtype=float32), array([0.8057986], dtype=float32), array([0.7580665], dtype=float32), array([0.923397], dtype=float32), array([0.9962742], dtype=float32), array([0.75279814], dtype=float32), array([0.9047118], dtype=float32), array([0.77618504], dtype=float32), array([0.8549177], dtype=float32), array([0.8928125], dtype=float32), array([0.9670736], dtype=float32), array([0.5747522], dtype=float32)]

In [22]:

scaled_test 

Out[22]:

array([[0.63116506], [0.82502778], [0.75972305], [0.94939738], [0.98743482], [0.82135225], [0.95956919], [0.80049577], [0.93025045], [0.95247457], [1.0661595 ], [0.65706471]])

Inverse Transformations and Compare

In [23]:

true_predictions = scaler.inverse_transform(test_predictions) true_predictions 

Out[23]:

array([[11073.90839344], [12458.03770655], [11899.6196956 ], [13833.82155687], [14686.41155297], [11837.98544043], [13615.22314852], [12111.58873272], [13032.68223149], [13476.01332593], [14344.79427296], [ 9755.02612317]])

In [24]:

test['Predictions'] = true_predictions test 

/opt/conda/lib/python3.6/site-packages/ipykernel_launcher.py:1: SettingWithCopyWarning: A value is trying to be set on a copy of a slice from a DataFrame. Try using .loc[row_indexer,col_indexer] = value instead See the caveats in the documentation: [http://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy](http://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy) """Entry point for launching an IPython kernel. 

Out[24]:

SalesPredictions

DATE

2018-02-011041511073.908393

2018-03-011268312458.037707

2018-04-011191911899.619696

2018-05-011413813833.821557

2018-06-011458314686.411553

2018-07-011264011837.985440

2018-08-011425713615.223149

2018-09-011239612111.588733

2018-10-011391413032.682231

2018-11-011417413476.013326

2018-12-011550414344.794273

2019-01-01107189755.026123

In [25]:

test.plot(figsize=(12,8)) 

Out[25]:

<matplotlib.axes._subplots.AxesSubplot at 0x7f70603e2390>

Saving and Loading Models

In [26]:

model.save('my_rnn_model.h5') '''from keras.models import load_model new_model = load_model('my_rnn_model.h5')''' 

Out[26]:

"from keras.models import load_model\nnew_model = load_model('my_rnn_model.h5')"

Experimental data used to create regression models of appliances energy use in a low energy building. Data Set Information: The data set is at 10 min for about 4.5 months. The house temperature and humidity conditions were monitored with a ZigBee wireless sensor network. Each wireless node transmitted the temperature and humidity conditions around 3.3 min. Then, the wireless data was averaged for 10 minutes periods. The energy data was logged every 10 minutes with m-bus energy meters. Weather from the nearest airport weather station (Chievres Airport, Belgium) was downloaded from a public data set from Reliable Prognosis (rp5.ru), and merged together with the experimental data sets using the date and time column. Two random variables have been included in the data set for testing the regression models and to filter out non predictive attributes (parameters).

Data

Let's read in the data set:

In [27]:

import pandas as pd import numpy as np %matplotlib inline import matplotlib.pyplot as plt df = pd.read_csv('../input/for-simple-exercises-time-series-forecasting/energydata_complete.csv',index_col='date', infer_datetime_format=True) df.head() 

Out[27]:

ApplianceslightsT1RH_1T2RH_2T3RH_3T4RH_4...T9RH_9T_outPress_mm_hgRH_outWindspeedVisibilityTdewpointrv1rv2

date

2016-01-11 17:00:00603019.8947.59666719.244.79000019.7944.73000019.00000045.566667...17.03333345.536.600000733.592.07.00000063.0000005.313.27543313.275433

2016-01-11 17:10:00603019.8946.69333319.244.72250019.7944.79000019.00000045.992500...17.06666745.566.483333733.692.06.66666759.1666675.218.60619518.606195

2016-01-11 17:20:00503019.8946.30000019.244.62666719.7944.93333318.92666745.890000...17.00000045.506.366667733.792.06.33333355.3333335.128.64266828.642668

2016-01-11 17:30:00504019.8946.06666719.244.59000019.7945.00000018.89000045.723333...17.00000045.406.250000733.892.06.00000051.5000005.045.41038945.410389

2016-01-11 17:40:00604019.8946.33333319.244.53000019.7945.00000018.89000045.530000...17.00000045.406.133333733.992.05.66666747.6666674.910.08409710.084097

5 rows × 28 columns

In [28]:

df.info() 

<class 'pandas.core.frame.DataFrame'> Index: 19735 entries, 2016-01-11 17:00:00 to 2016-05-27 18:00:00 Data columns (total 28 columns): Appliances 19735 non-null int64 lights 19735 non-null int64 T1 19735 non-null float64 RH_1 19735 non-null float64 T2 19735 non-null float64 RH_2 19735 non-null float64 T3 19735 non-null float64 RH_3 19735 non-null float64 T4 19735 non-null float64 RH_4 19735 non-null float64 T5 19735 non-null float64 RH_5 19735 non-null float64 T6 19735 non-null float64 RH_6 19735 non-null float64 T7 19735 non-null float64 RH_7 19735 non-null float64 T8 19735 non-null float64 RH_8 19735 non-null float64 T9 19735 non-null float64 RH_9 19735 non-null float64 T_out 19735 non-null float64 Press_mm_hg 19735 non-null float64 RH_out 19735 non-null float64 Windspeed 19735 non-null float64 Visibility 19735 non-null float64 Tdewpoint 19735 non-null float64 rv1 19735 non-null float64 rv2 19735 non-null float64 dtypes: float64(26), int64(2) memory usage: 4.4+ MB 

In [29]:

df['Windspeed'].plot(figsize=(12,8)) 

Out[29]:

<matplotlib.axes._subplots.AxesSubplot at 0x7f70583a95f8>

In [30]:

df['Appliances'].plot(figsize=(12,8)) 

Out[30]:

<matplotlib.axes._subplots.AxesSubplot at 0x7f705839f518>

Train Test Split

In [31]:

df = df.loc['2016-05-01':] df = df.round(2) print('len(df)',len(df)) test_days = 2 test_ind = test_days*144 # 24*60/10 = 144 test_ind 

len(df) 3853 

Out[31]:

288

In [32]:

train = df.iloc[:-test_ind] test = df.iloc[-test_ind:] 

Scale Data

In [33]:

from sklearn.preprocessing import MinMaxScaler scaler = MinMaxScaler() # IGNORE WARNING ITS JUST CONVERTING TO FLOATS # WE ONLY FIT TO TRAININ DATA, OTHERWISE WE ARE CHEATING ASSUMING INFO ABOUT TEST SET scaler.fit(train) 

Out[33]:

MinMaxScaler(copy=True, feature_range=(0, 1))

In [34]:

scaled_train = scaler.transform(train) scaled_test = scaler.transform(test) 

Time Series Generator

This class takes in a sequence of data-points gathered at equal intervals, along with time series parameters such as stride, length of history, etc., to produce batches for training/validation.

In [35]:

from tensorflow.keras.preprocessing.sequence import TimeseriesGenerator # define generator length = 144 # Length of the output sequences (in number of timesteps) batch_size = 1 #Number of timeseries samples in each batch generator = TimeseriesGenerator(scaled_train, scaled_train, length=length, batch_size=batch_size) 

In [36]:

print('len(scaled_train)',len(scaled_train)) print('len(generator) ',len(generator)) X,y = generator[0] print(f'Given the Array: \n{X.flatten()}') print(f'Predict this y: \n{y}') 

len(scaled_train) 3565 len(generator) 3421 Given the Array: [0.03896104 0. 0.13798978 ... 0.14319527 0.75185111 0.75185111] Predict this y: [[0.03896104 0. 0.30834753 0.29439421 0.16038492 0.49182278 0.0140056 0.36627907 0.24142857 0.24364791 0.12650602 0.36276002 0.12 0.28205572 0.06169297 0.15759185 0.34582624 0.39585974 0.09259259 0.39649608 0.18852459 0.96052632 0.59210526 0.1 0.58333333 0.13609467 0.4576746 0.4576746 ]] 

Create the Model

In [37]:

from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense,LSTM scaled_train.shape 

Out[37]:

(3565, 28)

In [38]:

# define model model = Sequential() # Simple RNN layer model.add(LSTM(100,input_shape=(length,scaled_train.shape[1]))) # Final Prediction (one neuron per feature) model.add(Dense(scaled_train.shape[1])) model.compile(optimizer='adam', loss='mse') model.summary() 

Model: "sequential" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= lstm (LSTM) (None, 100) 51600 _________________________________________________________________ dense (Dense) (None, 28) 2828 ================================================================= Total params: 54,428 Trainable params: 54,428 Non-trainable params: 0 _________________________________________________________________ 

EarlyStopping

In [39]:

from tensorflow.keras.callbacks import EarlyStopping early_stop = EarlyStopping(monitor='val_loss',patience=1) validation_generator = TimeseriesGenerator(scaled_test,scaled_test, length=length, batch_size=batch_size) model.fit_generator(generator,epochs=10, validation_data=validation_generator, callbacks=[early_stop]) 

Train for 3421 steps, validate for 144 steps Epoch 1/10 3421/3421 [==============================] - 182s 53ms/step - loss: 0.0114 - val_loss: 0.0102 Epoch 2/10 3421/3421 [==============================] - 180s 52ms/step - loss: 0.0079 - val_loss: 0.0086 Epoch 3/10 3421/3421 [==============================] - 181s 53ms/step - loss: 0.0075 - val_loss: 0.0084 Epoch 4/10 2295/3421 [===================>..........] - ETA: 58s - loss: 0.0073

In [40]:

model.history.history.keys() losses = pd.DataFrame(model.history.history) losses.plot() 

Out[40]:

<matplotlib.axes._subplots.AxesSubplot at 0x7f701f602fd0>

Evaluate on Test Data

In [41]:

first_eval_batch = scaled_train[-length:] first_eval_batch 

Out[41]:

array([[0.1038961 , 0. , 0.72231687, ..., 0.53550296, 0.15909546, 0.15909546], [0.11688312, 0. , 0.73424191, ..., 0.52662722, 0.40344207, 0.40344207], [0.11688312, 0. , 0.73424191, ..., 0.51775148, 0.20452271, 0.20452271], ..., [0.18181818, 0. , 0.70017036, ..., 0.50118343, 0.33340004, 0.33340004], [0.09090909, 0. , 0.70017036, ..., 0.51952663, 0.78747248, 0.78747248], [0.1038961 , 0. , 0.70017036, ..., 0.53846154, 0.77286372, 0.77286372]])

In [42]:

first_eval_batch = first_eval_batch.reshape((1, length, scaled_train.shape[1])) model.predict(first_eval_batch) 

Out[42]:

array([[ 0.10138211, 0.06747055, 0.7054 , 0.39806256, 0.54101586, 0.43319184, 0.4200446 , 0.4243666 , 0.7039989 , 0.40865916, 0.30799067, 0.36109492, 0.6687389 , -0.00205898, 0.6135764 , 0.42317435, 0.5408545 , 0.31506443, 0.49856254, 0.3375144 , 0.595571 , 0.53723574, 0.4301601 , 0.2183933 , 0.5878991 , 0.5141734 , 0.5099164 , 0.5046277 ]], dtype=float32)

In [43]:

scaled_test[0] 

Out[43]:

array([0.19480519, 0. , 0.70017036, 0.3920434 , 0.53007217, 0.41064526, 0.40616246, 0.41913319, 0.72714286, 0.4115245 , 0.30722892, 0.36445121, 0.66777778, 0. , 0.61119082, 0.39840637, 0.51618399, 0.32953105, 0.53703704, 0.34024896, 0.6057377 , 0.52631579, 0.41881579, 0.2 , 0.55283333, 0.53372781, 0.76305783, 0.76305783])

In [44]:

n_features = scaled_train.shape[1] test_predictions = [] first_eval_batch = scaled_train[-length:] current_batch = first_eval_batch.reshape((1, length, n_features)) for i in range(len(test)): # get prediction 1 time stamp ahead ([0] is for grabbing just the number instead of [array]) current_pred = model.predict(current_batch)[0] # store prediction test_predictions.append(current_pred) # update batch to now include prediction and drop first value current_batch = np.append(current_batch[:,1:,:],[[current_pred]],axis=1) 

Inverse Transformations and Compare

In [45]:

true_predictions = scaler.inverse_transform(test_predictions) true_predictions = pd.DataFrame(data=true_predictions,columns=test.columns) true_predictions 

Out[45]:

ApplianceslightsT1RH_1T2RH_2T3RH_3T4RH_4...T9RH_9T_outPress_mm_hgRH_outWindspeedVisibilityTdewpointrv1rv2

098.0642282.02411724.53069838.02643024.13646835.02824125.09911836.79901624.12799237.726848...21.79223837.17068716.231932756.34897556.6921682.18393340.2739457.28953025.49052425.226246

196.7347423.03212724.56049638.27405724.12363435.22240425.04828236.75549324.05867037.757009...21.62252237.03192815.869359756.84979856.7758432.40795340.4719357.04008025.58606325.403467

2101.3171283.65487724.58193338.45278424.10727435.39524624.98594536.73257924.00212037.867709...21.46573836.95288515.582083757.27725756.8520142.60464540.1515366.77541825.65402225.435035

3106.2275944.05048924.59547238.62635724.09213535.53003924.92815936.74073523.95754638.006228...21.32441436.89626315.331191757.60079756.7831162.78454739.6247516.53359825.68174625.425436

4110.2745624.31411124.60993138.81520324.08394135.67649824.88018536.79405223.92657638.167812...21.19696736.87120415.117654757.86148956.6735632.95541339.0301696.32080525.69815725.427384

..................................................................

283-484.899577-4.31702629.40432028.52185540.0727374.64098224.97573849.08468729.04299835.858090...22.88950035.01526661.924760746.902323-55.8979162.31187867.965786-5.10675428.44246035.991550

284-484.899210-4.31705729.40432928.52184540.0727444.64098024.97575449.08473029.04300135.858127...22.88950235.01528261.924766746.902294-55.8980882.31189367.965593-5.10682328.44246635.991547

285-484.899210-4.31708429.40433628.52182340.0727564.64095624.97577149.08476629.04300935.858155...22.88950335.01529161.924771746.902270-55.8982152.31190667.965450-5.10688728.44247835.991550

286-484.899119-4.31711129.40434528.52180240.0727724.64094424.97579149.08479629.04301435.858183...22.88950435.01529761.924806746.902253-55.8983512.31191067.965364-5.10693828.44250135.991532

287-484.899164-4.31713429.40435128.52177440.0727874.64091424.97581049.08483429.04302035.858207...22.88950435.01529761.924824746.902227-55.8984682.31191267.965279-5.10698228.44250735.991526

288 rows × 28 columns

In [46]:

import pandas as pd from fbprophet import Prophet 

Load Data

The input to Prophet is always a dataframe with two columns: ds and y. The ds (datestamp) column should be of a format expected by Pandas, ideally YYYY-MM-DD for a date or YYYY-MM-DD HH:MM:SS for a timestamp. The y column must be numeric, and represents the measurement we wish to forecast.

In [47]:

df = pd.read_csv('../input/for-simple-exercises-time-series-forecasting/Miles_Traveled.csv') df.head() 

Out[47]:

DATETRFVOLUSM227NFWA

01970-01-0180173.0

11970-02-0177442.0

21970-03-0190223.0

31970-04-0189956.0

41970-05-0197972.0

In [48]:

df.columns = ['ds','y'] df['ds'] = pd.to_datetime(df['ds']) df.info() 

<class 'pandas.core.frame.DataFrame'> RangeIndex: 588 entries, 0 to 587 Data columns (total 2 columns): ds 588 non-null datetime64[ns] y 588 non-null float64 dtypes: datetime64[ns](1), float64(1) memory usage: 9.3 KB 

In [49]:

pd.plotting.register_matplotlib_converters() try: df.plot(x='ds',y='y',figsize=(18,6)) except TypeError as e: figure_or_exception = str("TypeError: " + str(e)) else: figure_or_exception = df.set_index('ds').y.plot().get_figure() 

In [50]:

print('len(df)',len(df)) print('len(df) - 12 = ',len(df) - 12) 

len(df) 588 len(df) - 12 = 576 

In [51]:

train = df.iloc[:576] test = df.iloc[576:] 

Create and Fit Model

In [52]:

# This is fitting on all the data (no train test split in this example) m = Prophet() m.fit(train) 

Out[52]:

<fbprophet.forecaster.Prophet at 0x7f70730c06a0>

Forecasting

NOTE: Prophet by default is for daily data. You need to pass a frequency for sub-daily or monthly data. Info: https://facebook.github.io/prophet/docs/non-daily_data.html

In [53]:

future = m.make_future_dataframe(periods=12,freq='MS') forecast = m.predict(future) 

In [54]:

forecast.tail() 

Out[54]:

dstrendyhat_loweryhat_uppertrend_lowertrend_upperadditive_termsadditive_terms_loweradditive_terms_upperyearlyyearly_loweryearly_uppermultiplicative_termsmultiplicative_terms_lowermultiplicative_terms_upperyhat

5832018-08-01263410.800604274535.269790285644.123755263342.030655263476.98157516448.01304916448.01304916448.01304916448.01304916448.01304916448.0130490.00.00.0279858.813654

5842018-09-01263552.915940256177.190765267761.256896263449.458400263643.024845-1670.418537-1670.418537-1670.418537-1670.418537-1670.418537-1670.4185370.00.00.0261882.497404

5852018-10-01263690.446911263051.398780274886.109947263541.695987263825.1358335305.5058735305.5058735305.5058735305.5058735305.5058735305.5058730.00.00.0268995.952784

5862018-11-01263832.562247249806.070474261028.788020263640.580642264000.846531-8208.986942-8208.986942-8208.986942-8208.986942-8208.986942-8208.9869420.00.00.0255623.575305

5872018-12-01263970.093217251087.538081262731.050771263724.773757264186.916157-6922.716937-6922.716937-6922.716937-6922.716937-6922.716937-6922.7169370.00.00.0257047.376280

In [55]:

test.tail() 

Out[55]:

dsy

5832018-08-01286608.0

5842018-09-01260595.0

5852018-10-01282174.0

5862018-11-01258590.0

5872018-12-01268413.0

In [56]:

forecast.columns 

Out[56]:

Index(['ds', 'trend', 'yhat_lower', 'yhat_upper', 'trend_lower', 'trend_upper', 'additive_terms', 'additive_terms_lower', 'additive_terms_upper', 'yearly', 'yearly_lower', 'yearly_upper', 'multiplicative_terms', 'multiplicative_terms_lower', 'multiplicative_terms_upper', 'yhat'], dtype='object')

In [57]:

forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].tail(12) 

Out[57]:

dsyhatyhat_loweryhat_upper

5762018-01-01243850.453937238143.777398249480.190740

5772018-02-01235480.588794229702.624041241029.888771

5782018-03-01262683.274392256372.318521268163.016848

5792018-04-01262886.236399257227.047581269018.659587

5802018-05-01272609.522601266952.781615278452.756472

5812018-06-01272862.615300267443.492047278588.217647

5822018-07-01279321.841101273416.105839284843.281259

5832018-08-01279858.813654274535.269790285644.123755

5842018-09-01261882.497404256177.190765267761.256896

5852018-10-01268995.952784263051.398780274886.109947

5862018-11-01255623.575305249806.070474261028.788020

5872018-12-01257047.376280251087.538081262731.050771

Plotting Forecast

We can use Prophet's own built in plotting tools

In [58]:

m.plot(forecast); 

In [59]:

import matplotlib.pyplot as plt %matplotlib inline m.plot(forecast) plt.xlim(pd.to_datetime('2003-01-01'),pd.to_datetime('2007-01-01')) 

Out[59]:

(731216.0, 732677.0)

In [60]:

m.plot_components(forecast); 

In [61]:

from statsmodels.tools.eval_measures import rmse predictions = forecast.iloc[-12:]['yhat'] predictions 

Out[61]:

576 243850.453937 577 235480.588794 578 262683.274392 579 262886.236399 580 272609.522601 581 272862.615300 582 279321.841101 583 279858.813654 584 261882.497404 585 268995.952784 586 255623.575305 587 257047.376280 Name: yhat, dtype: float64

In [62]:

test['y'] 

Out[62]:

576 245695.0 577 226660.0 578 268480.0 579 272475.0 580 286164.0 581 280877.0 582 288145.0 583 286608.0 584 260595.0 585 282174.0 586 258590.0 587 268413.0 Name: y, dtype: float64

In [63]:

rmse(predictions,test['y']) 

Out[63]:

8618.783155559411

In [64]:

test.mean() 

Out[64]:

y 268739.666667 dtype: float64

Prophet Diagnostics

Prophet includes functionality for time series cross validation to measure forecast error using historical data. This is done by selecting cutoff points in the history, and for each of them fitting the model using data only up to that cutoff point. We can then compare the forecasted values to the actual values.

In [65]:

from fbprophet.diagnostics import cross_validation,performance_metrics from fbprophet.plot import plot_cross_validation_metric len(df) len(df)/12 # Initial 5 years training period initial = 5 * 365 initial = str(initial) + ' days' # Fold every 5 years period = 5 * 365 period = str(period) + ' days' # Forecast 1 year into the future horizon = 365 horizon = str(horizon) + ' days' df_cv = cross_validation(m, initial=initial, period=period, horizon = horizon) df_cv.head() 

Out[65]:

dsyhatyhat_loweryhat_upperycutoff

01977-01-01108479.087306107041.710385109884.311419102445.01976-12-11

11977-02-01102996.111502101502.260980104430.450535102416.01976-12-11

21977-03-01118973.317944117486.531273120346.494171119960.01976-12-11

31977-04-01120612.923539119090.079896122015.351195121513.01976-12-11

41977-05-01127883.031663126371.269290129257.086719128884.01976-12-11

In [66]:

df_cv.tail() 

Out[66]:

dsyhatyhat_loweryhat_upperycutoff

1032017-08-01273614.230765268044.449825279627.753972283184.02016-12-01

1042017-09-01255737.189562249987.360798261551.567277262673.02016-12-01

1052017-10-01262845.616157257365.064845268981.082903278937.02016-12-01

1062017-11-01249500.895087244208.004549255508.082651257712.02016-12-01

1072017-12-01250750.668713244667.910999256110.605457266535.02016-12-01

In [67]:

performance_metrics(df_cv) 

Out[67]:

horizonmsermsemaemapemdapecoverage

052 days2.402227e+074901.2518924506.3843710.0276310.0235930.4

153 days2.150811e+074637.6834074238.6627320.0248630.0235930.4

254 days1.807689e+074251.6925353708.9432750.0199330.0222780.5

355 days2.298205e+074793.9601544236.2752440.0230420.0235930.4

457 days2.078937e+074559.5357843972.0872700.0213170.0222780.5

........................

94360 days1.814608e+074259.8215153750.3594830.0195960.0195650.5

95361 days1.726110e+074154.6475363473.0373390.0182120.0189570.5

96362 days3.173990e+075633.8175084404.3007290.0220340.0247930.4

97364 days2.986513e+075464.9000404229.8698600.0213780.0216290.5

98365 days5.443147e+077377.7683775621.7078030.0265240.0247930.4

99 rows × 7 columns

In [68]:

plot_cross_validation_metric(df_cv, metric='rmse'); 

In [69]:

plot_cross_validation_metric(df_cv, metric='mape'); 

• What is the purpose of the study?

I am working on Deep Learning and Computer Vision in Flying Automobile Project. The project I am working on are Semantic segmentation (Aerial images) during the flight of the vehicle to find suitable areas where the vehicle can land. To make volumetric control of the vehicle to these areas.

With this kernel, I have completed working on the Semantic segmentation

1. What is semantic segmentation
2. Implementation of Segnet, FCN, UNet , PSPNet and other models in Keras
3. I extracted Github codes

Source: https://divamgupta.com/image-segmentation/2019/06/06/deep-learning-semantic-segmentation-keras.html

Semantic image segmentation is the task of classifying each pixel in an image from a predefined set of classes. In the following example, different entities are classified.

In the above example, the pixels belonging to the bed are classified in the class "bed", the pixels corresponding to the walls are labeled as "wall", etc.

In particular, our goal is to take an image of size W x H x 3 and generate a W x H matrix containing the predicted class ID's corresponding to all the pixels.

Usually, in an image with various entities, we want to know which pixel belongs to which entity, For example in an outdoor image, we can segment the sky, ground, trees, people, etc.

Semantic segmentation is different from object detection as it does not predict any bounding boxes around the objects. We do not distinguish between different instances of the same object. For example, there could be multiple cars in the scene and all of them would have the same label.

In order to perform semantic segmentation, a higher level understanding of the image is required. The algorithm should figure out the objects present and also the pixels which correspond to the object. Semantic segmentation is one of the essential tasks for complete scene understanding.

Dataset

The first step in training our segmentation model is to prepare the dataset. We would need the input RGB images and the corresponding segmentation images. If you want to make your own dataset, a tool like labelme or GIMP can be used to manually generate the ground truth segmentation masks.

Assign each class a unique ID. In the segmentation images, the pixel value should denote the class ID of the corresponding pixel. This is a common format used by most of the datasets and keras_segmentation. For the segmentation maps, do not use the jpg format as jpg is lossy and the pixel values might change. Use bmp or png format instead. And of course, the size of the input image and the segmentation image should be the same.

In the following example, pixel (0,0) is labeled as class 2, pixel (3,4) is labeled as class 1 and rest of the pixels are labeled as class 0.

In [1]:

import cv2 import numpy as np ann_img = np.zeros((30,30,3)).astype('uint8') ann_img[ 3 , 4 ] = 1 # this would set the label of pixel 3,4 as 1 ann_img[ 0 , 0 ] = 2 # this would set the label of pixel 0,0 as 2 

After generating the segmentation images, place them in the training/testing folder. Make separate folders for input images and the segmentation images. The file name of the input image and the corresponding segmentation image should be the same. For this tutorial we would be using a data-set which is already prepared. You can download it from here (Aerial Semantic Segmentation Drone Dataset).

Aerial Semantic Segmentation Drone Dataset

In [2]:

from PIL import Image import matplotlib.pyplot as plt %matplotlib inline original_image = "/kaggle/input/semantic-drone-dataset/dataset/semantic_drone_dataset/original_images/001.jpg" label_image_semantic = "/kaggle/input/semantic-drone-dataset/dataset/semantic_drone_dataset/label_images_semantic/001.png" fig, axs = plt.subplots(1, 2, figsize=(16, 8), constrained_layout=True) axs[0].imshow( Image.open(original_image)) axs[0].grid(False) label_image_semantic = Image.open(label_image_semantic) label_image_semantic = np.asarray(label_image_semantic) axs[1].imshow(label_image_semantic) axs[1].grid(False) 

Source Github Link: https://github.com/divamgupta/image-segmentation-keras

Output

In [3]:

!pip install keras-segmentation 

Train

In [4]:

kaggle_commit = True epochs = 20 if kaggle_commit: epochs = 5 

In [5]:

from keras_segmentation.models.unet import vgg_unet n_classes = 23 # Aerial Semantic Segmentation Drone Dataset tree, gras, other vegetation, dirt, gravel, rocks, water, paved area, pool, person, dog, car, bicycle, roof, wall, fence, fence-pole, window, door, obstacle model = vgg_unet(n_classes=n_classes , input_height=416, input_width=608 ) model.train( train_images = "/kaggle/input/semantic-drone-dataset/dataset/semantic_drone_dataset/original_images/", train_annotations = "/kaggle/input/semantic-drone-dataset/dataset/semantic_drone_dataset/label_images_semantic/", checkpoints_path = "vgg_unet" , epochs=epochs )

Train

In [4]:

kaggle_commit = True epochs = 20 if kaggle_commit: epochs = 5 

In [5]:

from keras_segmentation.models.unet import vgg_unet n_classes = 23 # Aerial Semantic Segmentation Drone Dataset tree, gras, other vegetation, dirt, gravel, rocks, water, paved area, pool, person, dog, car, bicycle, roof, wall, fence, fence-pole, window, door, obstacle model = vgg_unet(n_classes=n_classes , input_height=416, input_width=608 ) model.train( train_images = "/kaggle/input/semantic-drone-dataset/dataset/semantic_drone_dataset/original_images/", train_annotations = "/kaggle/input/semantic-drone-dataset/dataset/semantic_drone_dataset/label_images_semantic/", checkpoints_path = "vgg_unet" , epochs=epochs ) 

Using TensorFlow backend. 

Downloading data from https://github.com/fchollet/deep-learning-models/releases/download/v0.1/vgg16_weights_tf_dim_ordering_tf_kernels_notop.h5 58892288/58889256 [==============================] - 5s 0us/step 

 0%| | 0/400 [00:00<?, ?it/s]

Verifying training dataset 

100%|██████████| 400/400 [05:23<00:00, 1.24it/s] 

Dataset verified! Epoch 1/5 512/512 [==============================] - 693s 1s/step - loss: 1.4858 - accuracy: 0.5910 saved vgg_unet.0 Epoch 2/5 512/512 [==============================] - 690s 1s/step - loss: 1.1745 - accuracy: 0.6474 saved vgg_unet.1 Epoch 3/5 512/512 [==============================] - 689s 1s/step - loss: 1.0604 - accuracy: 0.6776 saved vgg_unet.2 Epoch 4/5 512/512 [==============================] - 692s 1s/step - loss: 0.9800 - accuracy: 0.7042 saved vgg_unet.3 Epoch 5/5 512/512 [==============================] - 692s 1s/step - loss: 0.9144 - accuracy: 0.7254 saved vgg_unet.4 

Prediction

In [6]:

import time from PIL import Image import matplotlib.pyplot as plt %matplotlib inline start = time.time() input_image = "/kaggle/input/semantic-drone-dataset/dataset/semantic_drone_dataset/original_images/001.jpg" out = model.predict_segmentation( inp=input_image, out_fname="out.png" ) fig, axs = plt.subplots(1, 3, figsize=(20, 20), constrained_layout=True) img_orig = Image.open(input_image) axs[0].imshow(img_orig) axs[0].set_title('original image-001.jpg') axs[0].grid(False) axs[1].imshow(out) axs[1].set_title('prediction image-out.png') axs[1].grid(False) validation_image = "/kaggle/input/semantic-drone-dataset/dataset/semantic_drone_dataset/label_images_semantic/001.png" axs[2].imshow( Image.open(validation_image)) axs[2].set_title('true label image-001.png') axs[2].grid(False) done = time.time() elapsed = done - start 

In [7]:

print(elapsed) print(out) print(out.shape) 

3.0578877925872803 [[0 1 0 ... 0 3 0] [0 1 1 ... 3 3 3] [0 1 1 ... 3 3 3] ... [0 1 1 ... 3 3 3] [0 1 1 ... 3 3 3] [0 1 1 ... 3 3 3]] (208, 304) 

Implementation of Segnet, FCN, UNet , PSPNet and other models in Keras the codes in this section do everything for you. You have no chance to interfere with the codes. I extracted these codes and wrote them open and open. We will have the chance to trade on the model as we wish.

In [8]:

import os os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' import keras from keras.models import * from keras.layers import * from types import MethodType import random import six import json from tqdm import tqdm import cv2 import numpy as np import itertools 

In [9]:

import sys print(sys.version) 

3.6.6 |Anaconda, Inc.| (default, Oct 9 2018, 12:34:16) [GCC 7.3.0] 

In [10]:

IMAGE_ORDERING_CHANNELS_FIRST = "channels_first" IMAGE_ORDERING_CHANNELS_LAST = "channels_last" # Default IMAGE_ORDERING = channels_last IMAGE_ORDERING = IMAGE_ORDERING_CHANNELS_LAST if IMAGE_ORDERING == 'channels_first': MERGE_AXIS = 1 elif IMAGE_ORDERING == 'channels_last': MERGE_AXIS = -1 if IMAGE_ORDERING == 'channels_first': pretrained_url = "https://github.com/fchollet/deep-learning-models/" \ "releases/download/v0.1/" \ "vgg16_weights_th_dim_ordering_th_kernels_notop.h5" elif IMAGE_ORDERING == 'channels_last': pretrained_url = "https://github.com/fchollet/deep-learning-models/" \ "releases/download/v0.1/" \ "vgg16_weights_tf_dim_ordering_tf_kernels_notop.h5" class_colors = [(random.randint(0, 255), random.randint( 0, 255), random.randint(0, 255)) for _ in range(5000)] 

In [11]:

def get_colored_segmentation_image( seg_arr , n_classes , colors=class_colors ): output_height = seg_arr.shape[0] output_width = seg_arr.shape[1] seg_img = np.zeros((output_height, output_width, 3)) for c in range(n_classes): seg_img[:, :, 0] += ((seg_arr[:, :] == c)*(colors[c][0])).astype('uint8') seg_img[:, :, 1] += ((seg_arr[:, :] == c)*(colors[c][1])).astype('uint8') seg_img[:, :, 2] += ((seg_arr[:, :] == c)*(colors[c][2])).astype('uint8') return seg_img 

In [12]:

def visualize_segmentation( seg_arr , inp_img=None , n_classes=None , colors=class_colors , class_names=None , overlay_img=False , show_legends=False , prediction_width=None , prediction_height=None ): if n_classes is None: n_classes = np.max(seg_arr) seg_img = get_colored_segmentation_image( seg_arr , n_classes , colors=colors ) if not inp_img is None: orininal_h = inp_img.shape[0] orininal_w = inp_img.shape[1] seg_img = cv2.resize(seg_img, (orininal_w, orininal_h)) if (not prediction_height is None) and (not prediction_width is None): seg_img = cv2.resize(seg_img, (prediction_width, prediction_height )) if not inp_img is None: inp_img = cv2.resize(inp_img, (prediction_width, prediction_height )) if overlay_img: assert not inp_img is None seg_img = overlay_seg_image( inp_img , seg_img ) if show_legends: assert not class_names is None legend_img = get_legends(class_names , colors=colors ) seg_img = concat_lenends( seg_img , legend_img ) return seg_img 

In [13]:

def get_image_array(image_input, width, height, imgNorm="sub_mean", ordering='channels_first'): """ Load image array from input """ if type(image_input) is np.ndarray: # It is already an array, use it as it is img = image_input elif isinstance(image_input, six.string_types) : if not os.path.isfile(image_input): raise DataLoaderError("get_image_array: path {0} doesn't exist".format(image_input)) img = cv2.imread(image_input, 1) else: raise DataLoaderError("get_image_array: Can't process input type {0}".format(str(type(image_input)))) if imgNorm == "sub_and_divide": img = np.float32(cv2.resize(img, (width, height))) / 127.5 - 1 elif imgNorm == "sub_mean": img = cv2.resize(img, (width, height)) img = img.astype(np.float32) img[:, :, 0] -= 103.939 img[:, :, 1] -= 116.779 img[:, :, 2] -= 123.68 img = img[:, :, ::-1] elif imgNorm == "divide": img = cv2.resize(img, (width, height)) img = img.astype(np.float32) img = img/255.0 if ordering == 'channels_first': img = np.rollaxis(img, 2, 0) return img def get_image_arr( path , width , height , imgNorm="sub_mean" , odering='channels_first' ):     if type( path ) is np.ndarray:         img = path     else:         img = cv2.imread(path, 1)     if imgNorm == "sub_and_divide":         img = np.float32(cv2.resize(img, ( width , height ))) / 127.5 - 1     elif imgNorm == "sub_mean":         img = cv2.resize(img, ( width , height ))         img = img.astype(np.float32)         img[:,:,0] -= 103.939         img[:,:,1] -= 116.779         img[:,:,2] -= 123.68         img = img[ : , : , ::-1 ]     elif imgNorm == "divide":         img = cv2.resize(img, ( width , height ))         img = img.astype(np.float32)         img = img/255.0     if odering == 'channels_first':         img = np.rollaxis(img, 2, 0)     return img def get_segmentation_array(image_input, nClasses, width, height, no_reshape=False): """ Load segmentation array from input """ seg_labels = np.zeros((height, width, nClasses)) if type(image_input) is np.ndarray: # It is already an array, use it as it is img = image_input elif isinstance(image_input, six.string_types) : if not os.path.isfile(image_input): raise DataLoaderError("get_segmentation_array: path {0} doesn't exist".format(image_input)) img = cv2.imread(image_input, 1) else: raise DataLoaderError("get_segmentation_array: Can't process input type {0}".format(str(type(image_input)))) img = cv2.resize(img, (width, height), interpolation=cv2.INTER_NEAREST) img = img[:, :, 0] for c in range(nClasses): seg_labels[:, :, c] = (img == c).astype(int) if not no_reshape: seg_labels = np.reshape(seg_labels, (width*height, nClasses)) return seg_labels 

In [14]:

def image_segmentation_generator(images_path, segs_path, batch_size, n_classes, input_height, input_width, output_height, output_width, do_augment=False ,augmentation_name="aug_all" ): img_seg_pairs = get_pairs_from_paths(images_path, segs_path) random.shuffle(img_seg_pairs) zipped = itertools.cycle(img_seg_pairs) while True: X = [] Y = [] for _ in range(batch_size): im, seg = next(zipped) im = cv2.imread(im, 1) seg = cv2.imread(seg, 1) if do_augment: im, seg[:, :, 0] = augment_seg(im, seg[:, :, 0] , augmentation_name=augmentation_name ) X.append(get_image_array(im, input_width, input_height, ordering=IMAGE_ORDERING)) Y.append(get_segmentation_array( seg, n_classes, output_width, output_height)) yield np.array(X), np.array(Y) 

In [15]:

def get_pairs_from_paths(images_path, segs_path, ignore_non_matching=False): """ Find all the images from the images_path directory and the segmentation images from the segs_path directory while checking integrity of data """ ACCEPTABLE_IMAGE_FORMATS = [".jpg", ".jpeg", ".png" , ".bmp"] ACCEPTABLE_SEGMENTATION_FORMATS = [".png", ".bmp"] image_files = [] segmentation_files = {} for dir_entry in os.listdir(images_path): if os.path.isfile(os.path.join(images_path, dir_entry)) and \ os.path.splitext(dir_entry)[1] in ACCEPTABLE_IMAGE_FORMATS: file_name, file_extension = os.path.splitext(dir_entry) image_files.append((file_name, file_extension, os.path.join(images_path, dir_entry))) for dir_entry in os.listdir(segs_path): if os.path.isfile(os.path.join(segs_path, dir_entry)) and \ os.path.splitext(dir_entry)[1] in ACCEPTABLE_SEGMENTATION_FORMATS: file_name, file_extension = os.path.splitext(dir_entry) if file_name in segmentation_files: raise DataLoaderError("Segmentation file with filename {0} already exists and is ambiguous to resolve with path {1}. Please remove or rename the latter.".format(file_name, os.path.join(segs_path, dir_entry))) segmentation_files[file_name] = (file_extension, os.path.join(segs_path, dir_entry)) return_value = [] # Match the images and segmentations for image_file, _, image_full_path in image_files: if image_file in segmentation_files: return_value.append((image_full_path, segmentation_files[image_file][1])) elif ignore_non_matching: continue else: # Error out raise DataLoaderError("No corresponding segmentation found for image {0}.".format(image_full_path)) return return_value 

In [16]:

def verify_segmentation_dataset(images_path, segs_path, n_classes, show_all_errors=False): try: img_seg_pairs = get_pairs_from_paths(images_path, segs_path) if not len(img_seg_pairs): print("Couldn't load any data from images_path: {0} and segmentations path: {1}".format(images_path, segs_path)) return False return_value = True for im_fn, seg_fn in tqdm(img_seg_pairs): img = cv2.imread(im_fn) seg = cv2.imread(seg_fn) # Check dimensions match if not img.shape == seg.shape: return_value = False print("The size of image {0} and its segmentation {1} doesn't match (possibly the files are corrupt).".format(im_fn, seg_fn)) if not show_all_errors: break else: max_pixel_value = np.max(seg[:, :, 0]) if max_pixel_value >= n_classes: return_value = False print("The pixel values of the segmentation image {0} violating range [0, {1}]. Found maximum pixel value {2}".format(seg_fn, str(n_classes - 1), max_pixel_value)) if not show_all_errors: break if return_value: print("Dataset verified! ") else: print("Dataset not verified!") return return_value except Exception as e: print("Found error during data loading\n{0}".format(str(e))) return False 

In [17]:

def evaluate( model=None , inp_images=None , annotations=None,inp_images_dir=None ,annotations_dir=None , checkpoints_path=None ): if model is None: assert (checkpoints_path is not None) , "Please provide the model or the checkpoints_path" model = model_from_checkpoint_path(checkpoints_path) if inp_images is None: assert (inp_images_dir is not None) , "Please privide inp_images or inp_images_dir" assert (annotations_dir is not None) , "Please privide inp_images or inp_images_dir" paths = get_pairs_from_paths(inp_images_dir , annotations_dir ) paths = list(zip(*paths)) inp_images = list(paths[0]) annotations = list(paths[1]) assert type(inp_images) is list assert type(annotations) is list tp = np.zeros( model.n_classes ) fp = np.zeros( model.n_classes ) fn = np.zeros( model.n_classes ) n_pixels = np.zeros( model.n_classes ) for inp , ann in tqdm( zip( inp_images , annotations )): pr = predict(model , inp ) gt = get_segmentation_array( ann , model.n_classes , model.output_width , model.output_height , no_reshape=True ) gt = gt.argmax(-1) pr = pr.flatten() gt = gt.flatten() for cl_i in range(model.n_classes ): tp[ cl_i ] += np.sum( (pr == cl_i) * (gt == cl_i) ) fp[ cl_i ] += np.sum( (pr == cl_i) * ((gt != cl_i)) ) fn[ cl_i ] += np.sum( (pr != cl_i) * ((gt == cl_i)) ) n_pixels[ cl_i ] += np.sum( gt == cl_i ) cl_wise_score = tp / ( tp + fp + fn + 0.000000000001 ) n_pixels_norm = n_pixels / np.sum(n_pixels) frequency_weighted_IU = np.sum(cl_wise_score*n_pixels_norm) mean_IU = np.mean(cl_wise_score) return {"frequency_weighted_IU":frequency_weighted_IU , "mean_IU":mean_IU , "class_wise_IU":cl_wise_score } 

In [18]:

def predict_multiple(model=None, inps=None, inp_dir=None, out_dir=None, checkpoints_path=None ,overlay_img=False , class_names=None , show_legends=False , colors=class_colors , prediction_width=None , prediction_height=None ): if model is None and (checkpoints_path is not None): model = model_from_checkpoint_path(checkpoints_path) if inps is None and (inp_dir is not None): inps = glob.glob(os.path.join(inp_dir, "*.jpg")) + glob.glob( os.path.join(inp_dir, "*.png")) + \ glob.glob(os.path.join(inp_dir, "*.jpeg")) assert type(inps) is list all_prs = [] for i, inp in enumerate(tqdm(inps)): if out_dir is None: out_fname = None else: if isinstance(inp, six.string_types): out_fname = os.path.join(out_dir, os.path.basename(inp)) else: out_fname = os.path.join(out_dir, str(i) + ".jpg") pr = predict( model, inp, out_fname , overlay_img=overlay_img,class_names=class_names ,show_legends=show_legends , colors=colors , prediction_width=prediction_width , prediction_height=prediction_height ) all_prs.append(pr) return all_prs 

In [19]:

def predict(model=None, inp=None, out_fname=None, checkpoints_path=None,overlay_img=False , class_names=None , show_legends=False , colors=class_colors , prediction_width=None , prediction_height=None ): if model is None and (checkpoints_path is not None): model = model_from_checkpoint_path(checkpoints_path) assert (inp is not None) assert((type(inp) is np.ndarray) or isinstance(inp, six.string_types) ), "Inupt should be the CV image or the input file name" if isinstance(inp, six.string_types): inp = cv2.imread(inp) assert len(inp.shape) == 3, "Image should be h,w,3 " orininal_h = inp.shape[0] orininal_w = inp.shape[1] output_width = model.output_width output_height = model.output_height input_width = model.input_width input_height = model.input_height n_classes = model.n_classes x = get_image_array(inp, input_width, input_height, ordering=IMAGE_ORDERING) pr = model.predict(np.array([x]))[0] pr = pr.reshape((output_height, output_width, n_classes)).argmax(axis=2) seg_img = visualize_segmentation( pr , inp ,n_classes=n_classes , colors=colors , overlay_img=overlay_img ,show_legends=show_legends ,class_names=class_names ,prediction_width=prediction_width , prediction_height=prediction_height ) if out_fname is not None: cv2.imwrite(out_fname, seg_img) return pr 

In [20]:

def train(model, train_images, train_annotations, input_height=None, input_width=None, n_classes=None, verify_dataset=True, checkpoints_path=None, epochs=5, batch_size=2, validate=False, val_images=None, val_annotations=None, val_batch_size=2, auto_resume_checkpoint=False, load_weights=None, steps_per_epoch=512, val_steps_per_epoch=512, gen_use_multiprocessing=False, ignore_zero_class=False , optimizer_name='adadelta' , do_augment=False , augmentation_name="aug_all" ): # check if user gives model name instead of the model object if isinstance(model, six.string_types): # create the model from the name assert (n_classes is not None), "Please provide the n_classes" if (input_height is not None) and (input_width is not None): model = model_from_name[model]( n_classes, input_height=input_height, input_width=input_width) else: model = model_from_name[model](n_classes) n_classes = model.n_classes input_height = model.input_height input_width = model.input_width output_height = model.output_height output_width = model.output_width if validate: assert val_images is not None assert val_annotations is not None if optimizer_name is not None: if ignore_zero_class: loss_k = masked_categorical_crossentropy else: loss_k = 'categorical_crossentropy' model.compile(loss= loss_k , optimizer=optimizer_name, metrics=['accuracy']) if checkpoints_path is not None: with open(checkpoints_path+"_config.json", "w") as f: json.dump({ "model_class": model.model_name, "n_classes": n_classes, "input_height": input_height, "input_width": input_width, "output_height": output_height, "output_width": output_width }, f) if load_weights is not None and len(load_weights) > 0: print("Loading weights from ", load_weights) model.load_weights(load_weights) if auto_resume_checkpoint and (checkpoints_path is not None): latest_checkpoint = find_latest_checkpoint(checkpoints_path) if latest_checkpoint is not None: print("Loading the weights from latest checkpoint ", latest_checkpoint) model.load_weights(latest_checkpoint) if verify_dataset: print("Verifying training dataset") verified = verify_segmentation_dataset(train_images, train_annotations, n_classes) assert verified if validate: print("Verifying validation dataset") verified = verify_segmentation_dataset(val_images, val_annotations, n_classes) assert verified train_gen = image_segmentation_generator( train_images, train_annotations, batch_size, n_classes, input_height, input_width, output_height, output_width , do_augment=do_augment ,augmentation_name=augmentation_name ) if validate: val_gen = image_segmentation_generator( val_images, val_annotations, val_batch_size, n_classes, input_height, input_width, output_height, output_width) if not validate: for ep in range(epochs): print("Starting Epoch ", ep) model.fit_generator(train_gen, steps_per_epoch, epochs=1, use_multiprocessing=True) if checkpoints_path is not None: model.save_weights(checkpoints_path + "." + str(ep)) print("saved ", checkpoints_path + ".model." + str(ep)) print("Finished Epoch", ep) else: for ep in range(epochs): print("Starting Epoch ", ep) model.fit_generator(train_gen, steps_per_epoch, validation_data=val_gen, validation_steps=val_steps_per_epoch, epochs=1 , use_multiprocessing=gen_use_multiprocessing) if checkpoints_path is not None: model.save_weights(checkpoints_path + "." + str(ep)) print("saved ", checkpoints_path + ".model." + str(ep)) print("Finished Epoch", ep) 

In [21]:

def get_segmentation_model(input, output): img_input = input o = output o_shape = Model(img_input, o).output_shape i_shape = Model(img_input, o).input_shape if IMAGE_ORDERING == 'channels_first': output_height = o_shape[2] output_width = o_shape[3] input_height = i_shape[2] input_width = i_shape[3] n_classes = o_shape[1] o = (Reshape((-1, output_height*output_width)))(o) o = (Permute((2, 1)))(o) elif IMAGE_ORDERING == 'channels_last': output_height = o_shape[1] output_width = o_shape[2] input_height = i_shape[1] input_width = i_shape[2] n_classes = o_shape[3] o = (Reshape((output_height*output_width, -1)))(o) o = (Activation('softmax'))(o) model = Model(img_input, o) model.output_width = output_width model.output_height = output_height model.n_classes = n_classes model.input_height = input_height model.input_width = input_width model.model_name = "" model.train = MethodType(train, model) model.predict_segmentation = MethodType(predict, model) model.predict_multiple = MethodType(predict_multiple, model) model.evaluate_segmentation = MethodType(evaluate, model) return model 

In [22]:

def get_vgg_encoder(input_height=224, input_width=224, pretrained='imagenet'): assert input_height % 32 == 0 assert input_width % 32 == 0 if IMAGE_ORDERING == 'channels_first': img_input = Input(shape=(3, input_height, input_width)) elif IMAGE_ORDERING == 'channels_last': img_input = Input(shape=(input_height, input_width, 3)) x = Conv2D(64, (3, 3), activation='relu', padding='same', name='block1_conv1', data_format=IMAGE_ORDERING)(img_input) x = Conv2D(64, (3, 3), activation='relu', padding='same', name='block1_conv2', data_format=IMAGE_ORDERING)(x) x = MaxPooling2D((2, 2), strides=(2, 2), name='block1_pool', data_format=IMAGE_ORDERING)(x) f1 = x # Block 2 x = Conv2D(128, (3, 3), activation='relu', padding='same', name='block2_conv1', data_format=IMAGE_ORDERING)(x) x = Conv2D(128, (3, 3), activation='relu', padding='same', name='block2_conv2', data_format=IMAGE_ORDERING)(x) x = MaxPooling2D((2, 2), strides=(2, 2), name='block2_pool', data_format=IMAGE_ORDERING)(x) f2 = x # Block 3 x = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv1', data_format=IMAGE_ORDERING)(x) x = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv2', data_format=IMAGE_ORDERING)(x) x = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv3', data_format=IMAGE_ORDERING)(x) x = MaxPooling2D((2, 2), strides=(2, 2), name='block3_pool', data_format=IMAGE_ORDERING)(x) f3 = x # Block 4 x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv1', data_format=IMAGE_ORDERING)(x) x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv2', data_format=IMAGE_ORDERING)(x) x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv3', data_format=IMAGE_ORDERING)(x) x = MaxPooling2D((2, 2), strides=(2, 2), name='block4_pool', data_format=IMAGE_ORDERING)(x) f4 = x # Block 5 x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv1', data_format=IMAGE_ORDERING)(x) x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv2', data_format=IMAGE_ORDERING)(x) x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv3', data_format=IMAGE_ORDERING)(x) x = MaxPooling2D((2, 2), strides=(2, 2), name='block5_pool', data_format=IMAGE_ORDERING)(x) f5 = x if pretrained == 'imagenet': VGG_Weights_path = keras.utils.get_file(pretrained_url.split("/")[-1], pretrained_url) Model(img_input, x).load_weights(VGG_Weights_path) return img_input, [f1, f2, f3, f4, f5] 

In [23]:

def _unet(n_classes, encoder, l1_skip_conn=True, input_height=416, input_width=608): img_input, levels = encoder( input_height=input_height, input_width=input_width) [f1, f2, f3, f4, f5] = levels o = f4 o = (ZeroPadding2D((1, 1), data_format=IMAGE_ORDERING))(o) o = (Conv2D(512, (3, 3), padding='valid', data_format=IMAGE_ORDERING))(o) o = (BatchNormalization())(o) o = (UpSampling2D((2, 2), data_format=IMAGE_ORDERING))(o) o = (concatenate([o, f3], axis=MERGE_AXIS)) o = (ZeroPadding2D((1, 1), data_format=IMAGE_ORDERING))(o) o = (Conv2D(256, (3, 3), padding='valid', data_format=IMAGE_ORDERING))(o) o = (BatchNormalization())(o) o = (UpSampling2D((2, 2), data_format=IMAGE_ORDERING))(o) o = (concatenate([o, f2], axis=MERGE_AXIS)) o = (ZeroPadding2D((1, 1), data_format=IMAGE_ORDERING))(o) o = (Conv2D(128, (3, 3), padding='valid', data_format=IMAGE_ORDERING))(o) o = (BatchNormalization())(o) o = (UpSampling2D((2, 2), data_format=IMAGE_ORDERING))(o) if l1_skip_conn: o = (concatenate([o, f1], axis=MERGE_AXIS)) o = (ZeroPadding2D((1, 1), data_format=IMAGE_ORDERING))(o) o = (Conv2D(64, (3, 3), padding='valid', data_format=IMAGE_ORDERING))(o) o = (BatchNormalization())(o) o = Conv2D(n_classes, (3, 3), padding='same',data_format=IMAGE_ORDERING)(o) model = get_segmentation_model(img_input, o) return model 

In [24]:

def vgg_unet(n_classes, input_height=416, input_width=608, encoder_level=3): model = _unet(n_classes, get_vgg_encoder,input_height=input_height, input_width=input_width) model.model_name = "vgg_unet" return model n_classes = 23 # Aerial Semantic Segmentation Drone Dataset tree, gras, other vegetation, dirt, gravel, rocks, water, paved area, pool, person, dog, car, bicycle, roof, wall, fence, fence-pole, window, door, obstacle model = vgg_unet(n_classes=n_classes, input_height=416, input_width=608) model_from_name = {} model_from_name["vgg_unet"] = vgg_unet 

Train

In [25]:

kaggle_commit = True epochs = 20 if kaggle_commit: epochs = 5 

In [26]:

model.train( train_images = "/kaggle/input/semantic-drone-dataset/dataset/semantic_drone_dataset/original_images/", train_annotations = "/kaggle/input/semantic-drone-dataset/dataset/semantic_drone_dataset/label_images_semantic/", checkpoints_path = "vgg_unet" , epochs=epochs ) 

 0%| | 0/400 [00:00<?, ?it/s]

Verifying training dataset 

100%|██████████| 400/400 [04:14<00:00, 1.57it/s] 

Dataset verified! Starting Epoch 0 Epoch 1/1 512/512 [==============================] - 751s 1s/step - loss: 1.5045 - accuracy: 0.5869 saved vgg_unet.model.0 Finished Epoch 0 Starting Epoch 1 Epoch 1/1 512/512 [==============================] - 756s 1s/step - loss: 1.1737 - accuracy: 0.6511 saved vgg_unet.model.1 Finished Epoch 1 Starting Epoch 2 Epoch 1/1 512/512 [==============================] - 730s 1s/step - loss: 1.0721 - accuracy: 0.6765 saved vgg_unet.model.2 Finished Epoch 2 Starting Epoch 3 Epoch 1/1 512/512 [==============================] - 759s 1s/step - loss: 1.0045 - accuracy: 0.6981 saved vgg_unet.model.3 Finished Epoch 3 Starting Epoch 4 Epoch 1/1 512/512 [==============================] - 759s 1s/step - loss: 0.9506 - accuracy: 0.7152 saved vgg_unet.model.4 Finished Epoch 4

• Officially launched in 1999, OpenCV (Open Source Computer Vision) from an Intel initiative.
• OpenCV's core is written in C++. In python we are simply using a wrapper that executes C++ code inside of python.
• First major release 1.0 was in 2006, second in 2009, third in 2015 and 4th in 2018. with OpenCV 4.0 Beta.
• It is an Open source library containing over 2500 optimized algorithms.
• It is EXTREMELY useful for almost all computer vision applications and is supported on Windows, Linux, MacOS, Android, iOS with bindings to Python, Java and Matlab.

Update(19.05.2020))

I will always try to improve this kernel. I made some additions to this version. Thanks for reading, I hope it will be useful

Newly Added Content

• 17.Background Subtraction Methods
• 18.Funny Mirrors Using OpenCV

Content

1. Sharpening
2. Thresholding, Binarization & Adaptive Thresholding
3. Dilation, Erosion, Opening and Closing
4. Edge Detection & Image Gradients
5. Perpsective Transform
6. Scaling, re-sizing and interpolations
7. Image Pyramids
8. Cropping
9. Blurring
10. Contours
11. Approximating Contours and Convex Hull
12. Identifiy Contours by Shape
13. Line Detection - Using Hough Lines
14. Counting Circles and Ellipses
15. Finding Corners
16. Finding Waldo
17. Background Subtraction Methods
18. Funny Mirrors Using OpenCV

Background Subtraction Methods Output

Funny Mirrors Using OpenCV Output

Some pictures from content

In [1]:

import numpy as np import matplotlib.pyplot as plt import cv2 

By altering our kernels we can implement sharpening, which has the effects of in strengthening or emphasizing edges in an image.

In [2]:

image = cv2.imread('/kaggle/input/opencv-samples-images/data/building.jpg') image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) plt.figure(figsize=(20, 20)) plt.subplot(1, 2, 1) plt.title("Original") plt.imshow(image) # Create our shapening kernel, we don't normalize since the # the values in the matrix sum to 1 kernel_sharpening = np.array([[-1,-1,-1], [-1,9,-1], [-1,-1,-1]]) # applying different kernels to the input image sharpened = cv2.filter2D(image, -1, kernel_sharpening) plt.subplot(1, 2, 2) plt.title("Image Sharpening") plt.imshow(sharpened) plt.show() 

In [3]:

# Load our new image image = cv2.imread('/kaggle/input/opencv-samples-images/Origin_of_Species.jpg', 0) plt.figure(figsize=(30, 30)) plt.subplot(3, 2, 1) plt.title("Original") plt.imshow(image) # Values below 127 goes to 0 (black, everything above goes to 255 (white) ret,thresh1 = cv2.threshold(image, 127, 255, cv2.THRESH_BINARY) plt.subplot(3, 2, 2) plt.title("Threshold Binary") plt.imshow(thresh1) # It's good practice to blur images as it removes noise image = cv2.GaussianBlur(image, (3, 3), 0) # Using adaptiveThreshold thresh = cv2.adaptiveThreshold(image, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY, 3, 5) plt.subplot(3, 2, 3) plt.title("Adaptive Mean Thresholding") plt.imshow(thresh) _, th2 = cv2.threshold(image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU) plt.subplot(3, 2, 4) plt.title("Otsu's Thresholding") plt.imshow(th2) plt.subplot(3, 2, 5) # Otsu's thresholding after Gaussian filtering blur = cv2.GaussianBlur(image, (5,5), 0) _, th3 = cv2.threshold(blur, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU) plt.title("Guassian Otsu's Thresholding") plt.imshow(th3) plt.show() 

In [4]:

image = cv2.imread('/kaggle/input/opencv-samples-images/data/LinuxLogo.jpg') image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) plt.figure(figsize=(20, 20)) plt.subplot(3, 2, 1) plt.title("Original") plt.imshow(image) # Let's define our kernel size kernel = np.ones((5,5), np.uint8) # Now we erode erosion = cv2.erode(image, kernel, iterations = 1) plt.subplot(3, 2, 2) plt.title("Erosion") plt.imshow(erosion) # dilation = cv2.dilate(image, kernel, iterations = 1) plt.subplot(3, 2, 3) plt.title("Dilation") plt.imshow(dilation) # Opening - Good for removing noise opening = cv2.morphologyEx(image, cv2.MORPH_OPEN, kernel) plt.subplot(3, 2, 4) plt.title("Opening") plt.imshow(opening) # Closing - Good for removing noise closing = cv2.morphologyEx(image, cv2.MORPH_CLOSE, kernel) plt.subplot(3, 2, 5) plt.title("Closing") plt.imshow(closing) 

Out[4]:

<matplotlib.image.AxesImage at 0x7fa9340f9f60>

In [5]:

image = cv2.imread('/kaggle/input/opencv-samples-images/data/fruits.jpg') image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) height, width,_ = image.shape # Extract Sobel Edges sobel_x = cv2.Sobel(image, cv2.CV_64F, 0, 1, ksize=5) sobel_y = cv2.Sobel(image, cv2.CV_64F, 1, 0, ksize=5) plt.figure(figsize=(20, 20)) plt.subplot(3, 2, 1) plt.title("Original") plt.imshow(image) plt.subplot(3, 2, 2) plt.title("Sobel X") plt.imshow(sobel_x) plt.subplot(3, 2, 3) plt.title("Sobel Y") plt.imshow(sobel_y) sobel_OR = cv2.bitwise_or(sobel_x, sobel_y) plt.subplot(3, 2, 4) plt.title("sobel_OR") plt.imshow(sobel_OR) laplacian = cv2.Laplacian(image, cv2.CV_64F) plt.subplot(3, 2, 5) plt.title("Laplacian") plt.imshow(laplacian) ## Then, we need to provide two values: threshold1 and threshold2. Any gradient value larger than threshold2 # is considered to be an edge. Any value below threshold1 is considered not to be an edge. #Values in between threshold1 and threshold2 are either classified as edges or non-edges based on how their #intensities are “connected”. In this case, any gradient values below 60 are considered non-edges #whereas any values above 120 are considered edges. # Canny Edge Detection uses gradient values as thresholds # The first threshold gradient canny = cv2.Canny(image, 50, 120) plt.subplot(3, 2, 6) plt.title("Canny") plt.imshow(canny) 

Out[5]:

<matplotlib.image.AxesImage at 0x7fa925f28358>

/opt/conda/lib/python3.6/site-packages/matplotlib/cm.py:273: RuntimeWarning: invalid value encountered in multiply xx = (xx * 255).astype(np.uint8) 

In [6]:

image = cv2.imread('/kaggle/input/opencv-samples-images/scan.jpg') image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) plt.figure(figsize=(20, 20)) plt.subplot(1, 2, 1) plt.title("Original") plt.imshow(image) # Cordinates of the 4 corners of the original image points_A = np.float32([[320,15], [700,215], [85,610], [530,780]]) # Cordinates of the 4 corners of the desired output # We use a ratio of an A4 Paper 1 : 1.41 points_B = np.float32([[0,0], [420,0], [0,594], [420,594]]) # Use the two sets of four points to compute # the Perspective Transformation matrix, M M = cv2.getPerspectiveTransform(points_A, points_B) warped = cv2.warpPerspective(image, M, (420,594)) plt.subplot(1, 2, 2) plt.title("warpPerspective") plt.imshow(warped) 

Out[6]:

<matplotlib.image.AxesImage at 0x7fa9374e1908>

Re-sizing is very easy using the cv2.resize function, it's arguments are: cv2.resize(image, dsize(output image size), x scale, y scale, interpolation)

In [7]:

image = cv2.imread('/kaggle/input/opencv-samples-images/data/fruits.jpg') image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) plt.figure(figsize=(20, 20)) plt.subplot(2, 2, 1) plt.title("Original") plt.imshow(image) # Let's make our image 3/4 of it's original size image_scaled = cv2.resize(image, None, fx=0.75, fy=0.75) plt.subplot(2, 2, 2) plt.title("Scaling - Linear Interpolation") plt.imshow(image_scaled) # Let's double the size of our image img_scaled = cv2.resize(image, None, fx=2, fy=2, interpolation = cv2.INTER_CUBIC) plt.subplot(2, 2, 3) plt.title("Scaling - Cubic Interpolation") plt.imshow(img_scaled) # Let's skew the re-sizing by setting exact dimensions img_scaled = cv2.resize(image, (900, 400), interpolation = cv2.INTER_AREA) plt.subplot(2, 2, 4) plt.title("Scaling - Skewed Size") plt.imshow(img_scaled) 

Out[7]:

<matplotlib.image.AxesImage at 0x7fa9374055c0>

Useful when scaling images in object detection.

In [8]:

image = cv2.imread('/kaggle/input/opencv-samples-images/data/butterfly.jpg') image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) plt.figure(figsize=(20, 20)) plt.subplot(2, 2, 1) plt.title("Original") plt.imshow(image) smaller = cv2.pyrDown(image) larger = cv2.pyrUp(smaller) plt.subplot(2, 2, 2) plt.title("Smaller") plt.imshow(smaller) plt.subplot(2, 2, 3) plt.title("Larger") plt.imshow(larger) 

Out[8]:

<matplotlib.image.AxesImage at 0x7fa925e03710>

In [9]:

image = cv2.imread('/kaggle/input/opencv-samples-images/data/messi5.jpg') image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) plt.figure(figsize=(20, 20)) plt.subplot(2, 2, 1) plt.title("Original") plt.imshow(image) height, width = image.shape[:2] # Let's get the starting pixel coordiantes (top left of cropping rectangle) start_row, start_col = int(height * .25), int(width * .25) # Let's get the ending pixel coordinates (bottom right) end_row, end_col = int(height * .75), int(width * .75) # Simply use indexing to crop out the rectangle we desire cropped = image[start_row:end_row , start_col:end_col] plt.subplot(2, 2, 2) plt.title("Cropped") plt.imshow(cropped) 

Out[9]:

<matplotlib.image.AxesImage at 0x7fa925d6c0b8>

In [10]:

image = cv2.imread('/kaggle/input/opencv-samples-images/data/home.jpg') image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) plt.figure(figsize=(20, 20)) plt.subplot(2, 2, 1) plt.title("Original") plt.imshow(image) # Creating our 3 x 3 kernel kernel_3x3 = np.ones((3, 3), np.float32) / 9 # We use the cv2.fitler2D to conovlve the kernal with an image blurred = cv2.filter2D(image, -1, kernel_3x3) plt.subplot(2, 2, 2) plt.title("3x3 Kernel Blurring") plt.imshow(blurred) # Creating our 7 x 7 kernel kernel_7x7 = np.ones((7, 7), np.float32) / 49 blurred2 = cv2.filter2D(image, -1, kernel_7x7) plt.subplot(2, 2, 3) plt.title("7x7 Kernel Blurring") plt.imshow(blurred2) 

Out[10]:

<matplotlib.image.AxesImage at 0x7fa925cab128>

In [11]:

# Let's load a simple image with 3 black squares image = cv2.imread('/kaggle/input/opencv-samples-images/data/pic3.png') image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) plt.figure(figsize=(20, 20)) plt.subplot(2, 2, 1) plt.title("Original") plt.imshow(image) # Grayscale gray = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY) # Find Canny edges edged = cv2.Canny(gray, 30, 200) plt.subplot(2, 2, 2) plt.title("Canny Edges") plt.imshow(edged) # Finding Contours # Use a copy of your image e.g. edged.copy(), since findContours alters the image contours, hierarchy = cv2.findContours(edged, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE) plt.subplot(2, 2, 3) plt.title("Canny Edges After Contouring") plt.imshow(edged) print("Number of Contours found = " + str(len(contours))) # Draw all contours # Use '-1' as the 3rd parameter to draw all cv2.drawContours(image, contours, -1, (0,255,0), 3) plt.subplot(2, 2, 4) plt.title("Contours") plt.imshow(image) 

Number of Contours found = 4 

Out[11]:

<matplotlib.image.AxesImage at 0x7fa925b185c0>

cv2.approxPolyDP(contour, Approximation Accuracy, Closed)

• contour -- is the individual contour we wish to approximate
• Approximation Accuracy -- Important parameter is determining the accuracy of the approximation. Small values give precise- approximations, large values give more generic approximation. A good rule of thumb is less than 5% of the contour perimeter
• Closed -- a Boolean value that states whether the approximate contour should be open or closed

In [12]:

# Load image and keep a copy image = cv2.imread('/kaggle/input/opencv-samples-images/house.jpg') image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) plt.figure(figsize=(20, 20)) plt.subplot(2, 2, 1) plt.title("Original") plt.imshow(image) orig_image = image.copy() # Grayscale and binarize gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) ret, thresh = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY_INV) # Find contours contours, hierarchy = cv2.findContours(thresh.copy(), cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE) # Iterate through each contour and compute the bounding rectangle for c in contours: x,y,w,h = cv2.boundingRect(c) cv2.rectangle(orig_image,(x,y),(x+w,y+h),(0,0,255),2) plt.subplot(2, 2, 2) plt.title("Bounding Rectangle") plt.imshow(orig_image) cv2.waitKey(0) # Iterate through each contour and compute the approx contour for c in contours: # Calculate accuracy as a percent of the contour perimeter accuracy = 0.03 * cv2.arcLength(c, True) approx = cv2.approxPolyDP(c, accuracy, True) cv2.drawContours(image, [approx], 0, (0, 255, 0), 2) plt.subplot(2, 2, 3) plt.title("Approx Poly DP") plt.imshow(image) plt.show() # Convex Hull image = cv2.imread('/kaggle/input/opencv-samples-images/hand.jpg') gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) plt.figure(figsize=(20, 20)) plt.subplot(1, 2, 1) plt.title("Original Image") plt.imshow(image) # Threshold the image ret, thresh = cv2.threshold(gray, 176, 255, 0) # Find contours contours, hierarchy = cv2.findContours(thresh.copy(), cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE) # Sort Contors by area and then remove the largest frame contour n = len(contours) - 1 contours = sorted(contours, key=cv2.contourArea, reverse=False)[:n] # Iterate through contours and draw the convex hull for c in contours: hull = cv2.convexHull(c) cv2.drawContours(image, [hull], 0, (0, 255, 0), 2) plt.subplot(1, 2, 2) plt.title("Convex Hull") plt.imshow(image) 

/opt/conda/lib/python3.6/site-packages/matplotlib/figure.py:98: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance. In a future version, a new instance will always be created and returned. Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance. "Adding an axes using the same arguments as a previous axes " 

In [13]:

image = cv2.imread('/kaggle/input/opencv-samples-images/someshapes.jpg') image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) plt.figure(figsize=(20, 20)) plt.subplot(2, 2, 1) plt.title("Original") plt.imshow(image) ret, thresh = cv2.threshold(gray, 127, 255, 1) # Extract Contours contours, hierarchy = cv2.findContours(thresh.copy(), cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE) for cnt in contours: # Get approximate polygons approx = cv2.approxPolyDP(cnt, 0.01*cv2.arcLength(cnt,True),True) if len(approx) == 3: shape_name = "Triangle" cv2.drawContours(image,[cnt],0,(0,255,0),-1) # Find contour center to place text at the center M = cv2.moments(cnt) cx = int(M['m10'] / M['m00']) cy = int(M['m01'] / M['m00']) cv2.putText(image, shape_name, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 0), 2) elif len(approx) == 4: x,y,w,h = cv2.boundingRect(cnt) M = cv2.moments(cnt) cx = int(M['m10'] / M['m00']) cy = int(M['m01'] / M['m00']) # Check to see if 4-side polygon is square or rectangle # cv2.boundingRect returns the top left and then width and if abs(w-h) <= 3: shape_name = "Square" # Find contour center to place text at the center cv2.drawContours(image, [cnt], 0, (0, 125 ,255), -1) cv2.putText(image, shape_name, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 0), 2) else: shape_name = "Rectangle" # Find contour center to place text at the center cv2.drawContours(image, [cnt], 0, (0, 0, 255), -1) M = cv2.moments(cnt) cx = int(M['m10'] / M['m00']) cy = int(M['m01'] / M['m00']) cv2.putText(image, shape_name, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 0), 2) elif len(approx) == 10: shape_name = "Star" cv2.drawContours(image, [cnt], 0, (255, 255, 0), -1) M = cv2.moments(cnt) cx = int(M['m10'] / M['m00']) cy = int(M['m01'] / M['m00']) cv2.putText(image, shape_name, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 0), 2) elif len(approx) >= 15: shape_name = "Circle" cv2.drawContours(image, [cnt], 0, (0, 255, 255), -1) M = cv2.moments(cnt) cx = int(M['m10'] / M['m00']) cy = int(M['m01'] / M['m00']) cv2.putText(image, shape_name, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 0), 2) plt.subplot(2, 2, 2) plt.title("Identifying Shapes") plt.imshow(image) 

Out[13]:

<matplotlib.image.AxesImage at 0x7fa9257c8470>

cv2.HoughLines(binarized/thresholded image, 𝜌 accuracy, 𝜃 accuracy, threshold)

• Threshold here is the minimum vote for it to be considered a line

In [14]:

image = cv2.imread('/kaggle/input/opencv-samples-images/data/sudoku.png') image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) plt.figure(figsize=(20, 20)) # Grayscale and Canny Edges extracted gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) edges = cv2.Canny(gray, 100, 170, apertureSize = 3) plt.subplot(2, 2, 1) plt.title("edges") plt.imshow(edges) # Run HoughLines using a rho accuracy of 1 pixel # theta accuracy of np.pi / 180 which is 1 degree # Our line threshold is set to 240 (number of points on line) lines = cv2.HoughLines(edges, 1, np.pi/180, 200) # We iterate through each line and convert it to the format # required by cv.lines (i.e. requiring end points) for line in lines: rho, theta = line[0] a = np.cos(theta) b = np.sin(theta) x0 = a * rho y0 = b * rho x1 = int(x0 + 1000 * (-b)) y1 = int(y0 + 1000 * (a)) x2 = int(x0 - 1000 * (-b)) y2 = int(y0 - 1000 * (a)) cv2.line(image, (x1, y1), (x2, y2), (255, 0, 0), 2) plt.subplot(2, 2, 2) plt.title("Hough Lines") plt.imshow(image) 

Out[14]:

<matplotlib.image.AxesImage at 0x7fa925768860>

In [15]:

image = cv2.imread('/kaggle/input/opencv-samples-images/blobs.jpg') image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) plt.figure(figsize=(20, 20)) # Intialize the detector using the default parameters detector = cv2.SimpleBlobDetector_create() # Detect blobs keypoints = detector.detect(image) # Draw blobs on our image as red circles blank = np.zeros((1,1)) blobs = cv2.drawKeypoints(image, keypoints, blank, (0,0,255), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS) number_of_blobs = len(keypoints) text = "Total Number of Blobs: " + str(len(keypoints)) cv2.putText(blobs, text, (20, 550), cv2.FONT_HERSHEY_SIMPLEX, 1, (100, 0, 255), 2) # Display image with blob keypoints plt.subplot(2, 2, 1) plt.title("Blobs using default parameters") plt.imshow(blobs) # Set our filtering parameters # Initialize parameter settiing using cv2.SimpleBlobDetector params = cv2.SimpleBlobDetector_Params() # Set Area filtering parameters params.filterByArea = True params.minArea = 100 # Set Circularity filtering parameters params.filterByCircularity = True params.minCircularity = 0.9 # Set Convexity filtering parameters params.filterByConvexity = False params.minConvexity = 0.2 # Set inertia filtering parameters params.filterByInertia = True params.minInertiaRatio = 0.01 # Create a detector with the parameters detector = cv2.SimpleBlobDetector_create(params) # Detect blobs keypoints = detector.detect(image) # Draw blobs on our image as red circles blank = np.zeros((1,1)) blobs = cv2.drawKeypoints(image, keypoints, blank, (0,255,0), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS) number_of_blobs = len(keypoints) text = "Number of Circular Blobs: " + str(len(keypoints)) cv2.putText(blobs, text, (20, 550), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 100, 255), 2) # Show blobs plt.subplot(2, 2, 2) plt.title("Filtering Circular Blobs Only") plt.imshow(blobs) 

Out[15]:

<matplotlib.image.AxesImage at 0x7fa92569a6d8>

In [16]:

# Load image then grayscale image = cv2.imread('/kaggle/input/opencv-samples-images/data/chessboard.png') image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) plt.figure(figsize=(10, 10)) gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) # The cornerHarris function requires the array datatype to be float32 gray = np.float32(gray) harris_corners = cv2.cornerHarris(gray, 3, 3, 0.05) #We use dilation of the corner points to enlarge them\ kernel = np.ones((7,7),np.uint8) harris_corners = cv2.dilate(harris_corners, kernel, iterations = 10) # Threshold for an optimal value, it may vary depending on the image. image[harris_corners > 0.025 * harris_corners.max() ] = [255, 127, 127] plt.subplot(1, 1, 1) plt.title("Harris Corners") plt.imshow(image) 

Out[16]:

<matplotlib.image.AxesImage at 0x7fa925618dd8>

In [17]:

# Load input image and convert to grayscale image = cv2.imread('/kaggle/input/opencv-samples-images/WaldoBeach.jpg') image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) plt.figure(figsize=(30, 30)) plt.subplot(2, 2, 1) plt.title("Where is Waldo?") plt.imshow(image) gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) # Load Template image template = cv2.imread('/kaggle/input/opencv-samples-images/waldo.jpg',0) result = cv2.matchTemplate(gray, template, cv2.TM_CCOEFF) min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(result) #Create Bounding Box top_left = max_loc bottom_right = (top_left[0] + 50, top_left[1] + 50) cv2.rectangle(image, top_left, bottom_right, (0,0,255), 5) plt.subplot(2, 2, 2) plt.title("Waldo") plt.imshow(image) 

Out[17]:

<matplotlib.image.AxesImage at 0x7fa9255abc88>

source: https://docs.opencv.org/3.4/d1/dc5/tutorial_background_subtraction.html

How to Use Background Subtraction Methods

Background subtraction (BS) is a common and widely used technique for generating a foreground mask (namely, a binary image containing the pixels belonging to moving objects in the scene) by using static cameras.

As the name suggests, BS calculates the foreground mask performing a subtraction between the current frame and a background model, containing the static part of the scene or, more in general, everything that can be considered as background given the characteristics of the observed scene.

In [18]:

import cv2 import matplotlib.pyplot as plt algo = 'MOG2' if algo == 'MOG2': backSub = cv2.createBackgroundSubtractorMOG2() else: backSub = cv2.createBackgroundSubtractorKNN() plt.figure(figsize=(20, 20)) frame = cv2.imread('/kaggle/input/opencv-samples-images/Background_Subtraction_Tutorial_frame.png') fgMask = backSub.apply(frame) plt.subplot(2, 2, 1) plt.title("Frame") plt.imshow(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)) plt.subplot(2, 2, 2) plt.title("FG Mask") plt.imshow(cv2.cvtColor(fgMask, cv2.COLOR_BGR2RGB)) frame = cv2.imread('/kaggle/input/opencv-samples-images/Background_Subtraction_Tutorial_frame_1.png') fgMask = backSub.apply(frame) plt.subplot(2, 2, 3) plt.title("Frame") plt.imshow(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)) plt.subplot(2, 2, 4) plt.title("FG Mask") plt.imshow(cv2.cvtColor(fgMask, cv2.COLOR_BGR2RGB)) 

Out[18]:

<matplotlib.image.AxesImage at 0x7fa9254bea20>

If you want to run it on video and locally, you must set it to (While) True. (Do not try on Kaggle you will get the error)-True.-(Do-not-try-on-Kaggle-you-will-get-the-error))

In [19]:

import cv2 import numpy as np algo = 'MOG2' inputt = '/kaggle/input/opencv-samples-images/video_input/Background_Subtraction_Tutorial_frame.mp4' capture = cv2.VideoCapture(cv2.samples.findFileOrKeep(inputt)) frame_width = int(capture.get(3)) frame_height = int(capture.get(4)) out = cv2.VideoWriter('Background_Subtraction_Tutorial_frame_output.mp4',cv2.VideoWriter_fourcc('M','J','P','G'),30, (frame_width,frame_height)) if algo == 'MOG2': backSub = cv2.createBackgroundSubtractorMOG2() else: backSub = cv2.createBackgroundSubtractorKNN() # If you want to run it on video and locally, you must set it to (While) True. (Do not try on Kaggle you will get the error) while False: ret, frame = capture.read() if frame is None: break fgMask = backSub.apply(frame) cv2.rectangle(frame, (10, 2), (100,20), (255,255,255), -1) cv2.imshow('Frame', frame) cv2.imshow('FG Mask', fgMask) out.write(cv2.cvtColor(fgMask, cv2.COLOR_BGR2RGB)) keyboard = cv2.waitKey(1) & 0xFF; if (keyboard == 27 or keyboard == ord('q')): cv2.destroyAllWindows() break; capture.release() out.release() cv2.destroyAllWindows() 

The result you will get on video and locally

Source: https://www.learnopencv.com/funny-mirrors-using-opencv/

Funny mirrors are not plane mirrors but a combination of convex/concave reflective surfaces that produce distortion effects that look funny as we move in front of these mirrors.

How does it work ?

The entire project can be divided into three major steps :

• Create a virtual camera.
• Define a 3D surface (the mirror surface) and project it into the virtual camera using a suitable value of projection matrix.
• Use the image coordinates of the projected points of the 3D surface to apply mesh based warping to get the desired effect of a funny mirror.

In [20]:

!pip install vcam 

Collecting vcam Downloading https://files.pythonhosted.org/packages/5a/81/31e561c9e2be275df47e313786932ce8e176f29616b65c19a1ef23ccaa3b/vcam-1.0-py3-none-any.whl Installing collected packages: vcam Successfully installed vcam-1.0 

In [21]:

import cv2 import numpy as np import math from vcam import vcam,meshGen import matplotlib.pyplot as plt plt.figure(figsize=(20, 20)) # Reading the input image. Pass the path of image you would like to use as input image. img = cv2.imread("/kaggle/input/opencv-samples-images/minions.jpg") H,W = img.shape[:2] # Creating the virtual camera object c1 = vcam(H=H,W=W) # Creating the surface object plane = meshGen(H,W) # We generate a mirror where for each 3D point, its Z coordinate is defined as Z = 20*exp^((x/w)^2 / 2*0.1*sqrt(2*pi)) plane.Z += 20*np.exp(-0.5*((plane.X*1.0/plane.W)/0.1)**2)/(0.1*np.sqrt(2*np.pi)) pts3d = plane.getPlane() pts2d = c1.project(pts3d) map_x,map_y = c1.getMaps(pts2d) output = cv2.remap(img,map_x,map_y,interpolation=cv2.INTER_LINEAR) plt.subplot(1, 2,1) plt.title("Funny Mirror") plt.imshow(cv2.cvtColor(np.hstack((img,output)), cv2.COLOR_BGR2RGB)) 

Out[21]:

<matplotlib.image.AxesImage at 0x7fa9259626a0>

So now as we know that by defining Z as a function of X and Y we can create different types of distortion effects. Let us create some more effects using the above code. We simply need to change the line where we define Z as a function of X and Y. This will further help you to create your own effects.

In [22]:

plt.figure(figsize=(20, 20)) # Reading the input image. Pass the path of image you would like to use as input image. img = cv2.imread("/kaggle/input/opencv-samples-images/minions.jpg") H,W = img.shape[:2] # Creating the virtual camera object c1 = vcam(H=H,W=W) # Creating the surface object plane = meshGen(H,W) # We generate a mirror where for each 3D point, its Z coordinate is defined as Z = 20*exp^((y/h)^2 / 2*0.1*sqrt(2*pi)) plane.Z += 20*np.exp(-0.5*((plane.Y*1.0/plane.H)/0.1)**2)/(0.1*np.sqrt(2*np.pi)) pts3d = plane.getPlane() pts2d = c1.project(pts3d) map_x,map_y = c1.getMaps(pts2d) output = cv2.remap(img,map_x,map_y,interpolation=cv2.INTER_LINEAR) plt.subplot(1, 2,1) plt.title("Funny Mirror") plt.imshow(cv2.cvtColor(np.hstack((img,output)), cv2.COLOR_BGR2RGB)) 

Out[22]:

<matplotlib.image.AxesImage at 0x7fa9258bbdd8>

Let's create something using sine function !

In [23]:

plt.figure(figsize=(20, 20)) # Reading the input image. Pass the path of image you would like to use as input image. img = cv2.imread("/kaggle/input/opencv-samples-images/minions.jpg") H,W = img.shape[:2] # Creating the virtual camera object c1 = vcam(H=H,W=W) # Creating the surface object plane = meshGen(H,W) # We generate a mirror where for each 3D point, its Z coordinate is defined as Z = 20*[ sin(2*pi*(x/w-1/4))) + sin(2*pi*(y/h-1/4))) ] plane.Z += 20*np.sin(2*np.pi*((plane.X-plane.W/4.0)/plane.W)) + 20*np.sin(2*np.pi*((plane.Y-plane.H/4.0)/plane.H)) pts3d = plane.getPlane() pts2d = c1.project(pts3d) map_x,map_y = c1.getMaps(pts2d) output = cv2.remap(img,map_x,map_y,interpolation=cv2.INTER_LINEAR) plt.subplot(1, 2,1) plt.title("Funny Mirror") plt.imshow(cv2.cvtColor(np.hstack((img,output)), cv2.COLOR_BGR2RGB)) 

Out[23]:

<matplotlib.image.AxesImage at 0x7fa925a115f8>

Content

Regression

• Linear Regression
• Multiple Linear Regression
• Polynomial Linear Regression
• Support Vector Regression
• Decision Tree Regression
• Random Forest Regression

Classification

• K-Nearest Neighbour (KNN) Classification
• Support Vector Machine (SVM) Classification
• Naive Bayes Classification
• Decision Tree Classification
• Random Forest Classification

Clustering

• K-Means Clustering
• Hierarchical Clustering

Other Content

• Natural Language Process (NLP)
• Principal Component Analysis (PCA)
• Model Selection
• Recommendation Systems

Regression

In [1]:

# import library import pandas as pd import matplotlib.pyplot as plt import math # import data data = pd.read_csv("../input/linearregressiondataset3/linear-regression-dataset.csv") print(data.info()) print(data.head()) #print(data.describe()) 

<class 'pandas.core.frame.DataFrame'> RangeIndex: 14 entries, 0 to 13 Data columns (total 2 columns): deneyim 14 non-null float64 maas 14 non-null int64 dtypes: float64(1), int64(1) memory usage: 304.0 bytes None deneyim maas 0 0.5 2500 1 0.0 2250 2 1.0 2750 3 5.0 8000 4 8.0 9000 

In [2]:

# plot data plt.scatter(data.deneyim,data.maas) plt.xlabel("deneyim") plt.ylabel("maas") plt.show() 

In [3]:

#%% linear regression # sklearn library from sklearn.linear_model import LinearRegression # linear regression model linear_reg = LinearRegression() x = data.deneyim.values.reshape(-1,1) y = data.maas.values.reshape(-1,1) linear_reg.fit(x,y) print('R sq: ', linear_reg.score(x, y)) print('Correlation: ', math.sqrt(linear_reg.score(x, y))) 

R sq: 0.9775283164949903 Correlation: 0.9887003168275968 

In [4]:

#%% prediction import numpy as np print("Coefficient for X: ", linear_reg.coef_) print("Intercept for X: ", linear_reg.intercept_) print("Regression line is: y = " + str(linear_reg.intercept_[0]) + " + (x * " + str(linear_reg.coef_[0][0]) + ")") # maas = 1663 + 1138*deneyim maas_yeni = 1663 + 1138*11 print(maas_yeni) array = np.array([11]).reshape(-1,1) print(linear_reg.predict(array)) 

Coefficient for X: [[1138.34819698]] Intercept for X: [1663.89519747] Regression line is: y = 1663.8951974741067 + (x * 1138.3481969755717) 14181 [[14185.72536421]] 

In [5]:

# visualize line array = np.array([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]).reshape(-1,1) # deneyim plt.scatter(x,y) #plt.show() y_head = linear_reg.predict(array) # maas plt.plot(array, y_head,color = "red") array = np.array([100]).reshape(-1,1) linear_reg.predict(array) 

Out[5]:

array([[115498.71489503]])

In [6]:

y_head = linear_reg.predict(x) # maas from sklearn.metrics import r2_score print("r_square score: ", r2_score(y,y_head)) 

r_square score: 0.9775283164949903 

In [7]:

import pandas as pd import numpy as np from sklearn.linear_model import LinearRegression data = pd.read_csv("../input/multiplelinearregressiondataset/multiple-linear-regression-dataset.csv") print(data.info()) print(data.head()) #print(data.describe()) 

<class 'pandas.core.frame.DataFrame'> RangeIndex: 14 entries, 0 to 13 Data columns (total 3 columns): deneyim 14 non-null float64 maas 14 non-null int64 yas 14 non-null int64 dtypes: float64(1), int64(2) memory usage: 416.0 bytes None deneyim maas yas 0 0.5 2500 22 1 0.0 2250 21 2 1.0 2750 23 3 5.0 8000 25 4 8.0 9000 28 

In [8]:

x = data.iloc[:,[0,2]].values y = data.maas.values.reshape(-1,1) multiple_linear_regression = LinearRegression() multiple_linear_regression.fit(x,y) print("b0: ",multiple_linear_regression.intercept_) print("b1: ", multiple_linear_regression.coef_) #predict x_ = np.array([[10,35],[5,35]]) multiple_linear_regression.predict(x_) y_head = multiple_linear_regression.predict(x) from sklearn.metrics import r2_score print("r_square score: ", r2_score(y,y_head)) 

b0: [10376.62747228] b1: [[1525.50072054 -416.72218625]] r_square score: 0.9818393838730447 

In [9]:

import pandas as pd import matplotlib.pyplot as plt data = pd.read_csv("../input/polynomialregressioncsv/polynomial-regression.csv") print(data.info()) print(data.head()) #print(data.describe()) 

<class 'pandas.core.frame.DataFrame'> RangeIndex: 15 entries, 0 to 14 Data columns (total 2 columns): araba_fiyat 15 non-null int64 araba_max_hiz 15 non-null int64 dtypes: int64(2) memory usage: 320.0 bytes None araba_fiyat araba_max_hiz 0 60 180 1 70 180 2 80 200 3 100 200 4 120 200 

In [10]:

x = data.araba_fiyat.values.reshape(-1,1) y = data.araba_max_hiz.values.reshape(-1,1) plt.scatter(x,y) plt.xlabel("araba_max_hiz") plt.ylabel("araba_fiyat") plt.show() 

In [11]:

# polynomial regression = y = b0 + b1*x +b2*x^2 + b3*x^3 + ... + bn*x^n from sklearn.preprocessing import PolynomialFeatures from sklearn.linear_model import LinearRegression polynominal_regression = PolynomialFeatures(degree=4) x_polynomial = polynominal_regression.fit_transform(x,y) # %% fit linear_regression = LinearRegression() linear_regression.fit(x_polynomial,y) # %% y_head2 = linear_regression.predict(x_polynomial) plt.plot(x,y_head2,color= "green",label = "poly") plt.legend() plt.scatter(x,y) plt.xlabel("araba_max_hiz") plt.ylabel("araba_fiyat") plt.show() from sklearn.metrics import r2_score print("r_square score: ", r2_score(y,y_head2)) 

r_square score: 0.9694743023124649 

In [12]:

import pandas as pd import matplotlib.pyplot as plt data = pd.read_csv("../input/support-vector-regression/maaslar.csv") print(data.info()) print(data.head()) #print(data.describe()) 

<class 'pandas.core.frame.DataFrame'> RangeIndex: 10 entries, 0 to 9 Data columns (total 3 columns): unvan 10 non-null object Egitim Seviyesi 10 non-null int64 maas 10 non-null int64 dtypes: int64(2), object(1) memory usage: 320.0+ bytes None unvan Egitim Seviyesi maas 0 Cayci 1 2250 1 Sekreter 2 2500 2 Uzman Yardimcisi 3 3000 3 Uzman 4 4000 4 Proje Yoneticisi 5 5500 

In [13]:

x = data.iloc[:,1:2].values y = data.iloc[:,2:].values plt.scatter(x,y) plt.xlabel("araba_max_hiz") plt.ylabel("araba_fiyat") plt.show() 

In [14]:

#verilerin olceklenmesi from sklearn.preprocessing import StandardScaler sc1 = StandardScaler() x_olcekli = sc1.fit_transform(x) sc2 = StandardScaler() y_olcekli = sc2.fit_transform(y) #%% SVR from sklearn.svm import SVR svr_reg = SVR(kernel = 'rbf') svr_reg.fit(x_olcekli,y_olcekli) y_head = svr_reg.predict(x_olcekli) # visualize line plt.plot(x_olcekli,y_head,color= "green",label = "SVR") plt.legend() plt.scatter(x_olcekli,y_olcekli,color='red') plt.show() print('R sq: ', svr_reg.score(x_olcekli, y_olcekli)) 

/opt/conda/lib/python3.6/site-packages/sklearn/utils/validation.py:585: DataConversionWarning: Data with input dtype int64 was converted to float64 by StandardScaler. warnings.warn(msg, DataConversionWarning) /opt/conda/lib/python3.6/site-packages/sklearn/utils/validation.py:585: DataConversionWarning: Data with input dtype int64 was converted to float64 by StandardScaler. warnings.warn(msg, DataConversionWarning) /opt/conda/lib/python3.6/site-packages/sklearn/utils/validation.py:585: DataConversionWarning: Data with input dtype int64 was converted to float64 by StandardScaler. warnings.warn(msg, DataConversionWarning) /opt/conda/lib/python3.6/site-packages/sklearn/utils/validation.py:585: DataConversionWarning: Data with input dtype int64 was converted to float64 by StandardScaler. warnings.warn(msg, DataConversionWarning) /opt/conda/lib/python3.6/site-packages/sklearn/utils/validation.py:747: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel(). y = column_or_1d(y, warn=True) 

R sq: 0.7513836788854973 

In [15]:

import pandas as pd import matplotlib.pyplot as plt import numpy as np data = pd.read_csv("../input/decisiontreeregressiondataset/decision-tree-regression-dataset.csv", header=None) print(data.info()) print(data.head()) #print(data.describe()) 

<class 'pandas.core.frame.DataFrame'> RangeIndex: 10 entries, 0 to 9 Data columns (total 2 columns): 0 10 non-null int64 1 10 non-null int64 dtypes: int64(2) memory usage: 240.0 bytes None 0 1 0 1 100 1 2 80 2 3 70 3 4 60 4 5 50 

In [16]:

x = data.iloc[:,[0]].values.reshape(-1,1) y = data.iloc[:,[1]].values.reshape(-1,1) 

In [17]:

#%% decision tree regression from sklearn.tree import DecisionTreeRegressor tree_reg = DecisionTreeRegressor() tree_reg.fit(x,y) print(tree_reg.predict(np.array([5.5]).reshape(-1,1))) 

[50.] 

In [18]:

x_ = np.arange(min(x),max(x),0.01).reshape(-1,1) #print(x) y_head = tree_reg.predict(x_) #print(y_head) # %% visualize plt.scatter(x,y,color="red") plt.plot(x_,y_head,color = "green") plt.xlabel("tribun level") plt.ylabel("ucret") plt.show() y_head = tree_reg.predict(x) #from sklearn.metrics import r2_score print("r_square score: ", r2_score(y,y_head)) 

r_square score: 1.0 

In [19]:

import pandas as pd import matplotlib.pyplot as plt import numpy as np data = pd.read_csv("../input/randomforestregressiondataset/random-forest-regression-dataset.csv", header=None) print(data.info()) print(data.head()) #print(data.describe()) 

<class 'pandas.core.frame.DataFrame'> RangeIndex: 10 entries, 0 to 9 Data columns (total 2 columns): 0 10 non-null int64 1 10 non-null int64 dtypes: int64(2) memory usage: 240.0 bytes None 0 1 0 1 100 1 2 80 2 3 70 3 4 60 4 5 50 

In [20]:

x = data.iloc[:,0].values.reshape(-1,1) y = data.iloc[:,1].values.reshape(-1,1) 

In [21]:

from sklearn.ensemble import RandomForestRegressor rf = RandomForestRegressor(n_estimators = 100, random_state= 42) rf.fit(x,y) print("7.8 seviyesinde fiyatın ne kadar olduğu: ",rf.predict(np.array([7.8]).reshape(-1,1))) x_ = np.arange(min(x),max(x),0.01).reshape(-1,1) y_head = rf.predict(x_) 

7.8 seviyesinde fiyatın ne kadar olduğu: [22.7] 

/opt/conda/lib/python3.6/site-packages/ipykernel_launcher.py:3: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel(). This is separate from the ipykernel package so we can avoid doing imports until 

In [22]:

# visualize plt.scatter(x,y,color="red") plt.plot(x_,y_head,color="green") plt.xlabel("tribun level") plt.ylabel("ucret") plt.show() 

In [23]:

y_head = rf.predict(x) from sklearn.metrics import r2_score print("r_score: ", r2_score(y,y_head)) 

r_score: 0.9798724794092587 

Classification

-Classification)

In [24]:

import pandas as pd import matplotlib.pyplot as plt import numpy as np data = pd.read_csv("../input/classification/data.csv") #print(data.info()) #print(data.head()) #print(data.describe()) # %% data.drop(["id","Unnamed: 32"],axis=1,inplace=True) data.tail() # malignant = M kotu huylu tumor # benign = B iyi huylu tumor 

In [25]:

# %% M = data[data.diagnosis == "M"] B = data[data.diagnosis == "B"] # scatter plot plt.scatter(M.radius_mean,M.texture_mean,color="red",label="kotu",alpha= 0.3) plt.scatter(B.radius_mean,B.texture_mean,color="green",label="iyi",alpha= 0.3) plt.xlabel("radius_mean") plt.ylabel("texture_mean") plt.legend() plt.show() 

In [26]:

# %% data.diagnosis = [1 if each == "M" else 0 for each in data.diagnosis] y = data.diagnosis.values x_data = data.drop(["diagnosis"],axis=1) # %% # normalization x = (x_data - np.min(x_data))/(np.max(x_data)-np.min(x_data)) 

In [27]:

#%% # train test split from sklearn.model_selection import train_test_split x_train, x_test, y_train, y_test = train_test_split(x,y,test_size = 0.3,random_state=1) # %% # knn model from sklearn.neighbors import KNeighborsClassifier knn = KNeighborsClassifier(n_neighbors = 3) # n_neighbors = k knn.fit(x_train,y_train) prediction = knn.predict(x_test) print(" {} nn score: {} ".format(3,knn.score(x_test,y_test))) 

 3 nn score: 0.9532163742690059 

In [28]:

# %% # find k value score_list = [] for each in range(1,15): knn2 = KNeighborsClassifier(n_neighbors = each) knn2.fit(x_train,y_train) score_list.append(knn2.score(x_test,y_test)) plt.plot(range(1,15),score_list) plt.xlabel("k values") plt.ylabel("accuracy") plt.show() 

In [29]:

# %% # knn model knn = KNeighborsClassifier(n_neighbors = 8) # n_neighbors = k knn.fit(x_train,y_train) prediction = knn.predict(x_test) print(" {} nn score: {} ".format(3,knn.score(x_test,y_test))) 

 3 nn score: 0.9649122807017544 

In [30]:

#%% confusion matrix y_pred = knn.predict(x_test) y_true = y_test from sklearn.metrics import confusion_matrix cm = confusion_matrix(y_true,y_pred) # %% cm visualization import seaborn as sns f, ax = plt.subplots(figsize =(5,5)) sns.heatmap(cm,annot = True,linewidths=0.5,linecolor="red",fmt = ".0f",ax=ax) plt.xlabel("y_pred") plt.ylabel("y_true") plt.show() 

-Classification)

In [31]:

import pandas as pd import matplotlib.pyplot as plt import numpy as np data = pd.read_csv("../input/classification/data.csv") #print(data.info()) #print(data.head()) #print(data.describe()) # %% data.drop(["id","Unnamed: 32"],axis=1,inplace=True) data.tail() # malignant = M kotu huylu tumor # benign = B iyi huylu tumor 

In [32]:

# %% M = data[data.diagnosis == "M"] B = data[data.diagnosis == "B"] # scatter plot plt.scatter(M.radius_mean,M.texture_mean,color="red",label="kotu",alpha= 0.3) plt.scatter(B.radius_mean,B.texture_mean,color="green",label="iyi",alpha= 0.3) plt.xlabel("radius_mean") plt.ylabel("texture_mean") plt.legend() plt.show() 

In [33]:

# %% data.diagnosis = [1 if each == "M" else 0 for each in data.diagnosis] y = data.diagnosis.values x_data = data.drop(["diagnosis"],axis=1) # %% # normalization x = (x_data - np.min(x_data))/(np.max(x_data)-np.min(x_data)) 

In [34]:

#%% # train test split from sklearn.model_selection import train_test_split x_train, x_test, y_train, y_test = train_test_split(x,y,test_size = 0.3,random_state=1) # %% SVM from sklearn.svm import SVC svm = SVC(random_state = 1) svm.fit(x_train,y_train) # %% test print("print accuracy of svm algo: ",svm.score(x_test,y_test)) 

print accuracy of svm algo: 0.9532163742690059 

/opt/conda/lib/python3.6/site-packages/sklearn/svm/base.py:196: FutureWarning: The default value of gamma will change from 'auto' to 'scale' in version 0.22 to account better for unscaled features. Set gamma explicitly to 'auto' or 'scale' to avoid this warning. "avoid this warning.", FutureWarning) 

In [35]:

#%% confusion matrix y_pred = svm.predict(x_test) y_true = y_test from sklearn.metrics import confusion_matrix cm = confusion_matrix(y_true,y_pred) # %% cm visualization import seaborn as sns f, ax = plt.subplots(figsize =(5,5)) sns.heatmap(cm,annot = True,linewidths=0.5,linecolor="red",fmt = ".0f",ax=ax) plt.xlabel("y_pred") plt.ylabel("y_true") plt.show() 

In [36]:

import pandas as pd import matplotlib.pyplot as plt import numpy as np data = pd.read_csv("../input/classification/data.csv") #print(data.info()) #print(data.head()) #print(data.describe()) # %% data.drop(["id","Unnamed: 32"],axis=1,inplace=True) data.tail() # malignant = M kotu huylu tumor # benign = B iyi huylu tumor 

In [37]:

# %% M = data[data.diagnosis == "M"] B = data[data.diagnosis == "B"] # scatter plot plt.scatter(M.radius_mean,M.texture_mean,color="red",label="kotu",alpha= 0.3) plt.scatter(B.radius_mean,B.texture_mean,color="green",label="iyi",alpha= 0.3) plt.xlabel("radius_mean") plt.ylabel("texture_mean") plt.legend() plt.show() 

In [38]:

# %% data.diagnosis = [1 if each == "M" else 0 for each in data.diagnosis] y = data.diagnosis.values x_data = data.drop(["diagnosis"],axis=1) # %% # normalization x = (x_data - np.min(x_data))/(np.max(x_data)-np.min(x_data)) 

In [39]:

#%% # train test split from sklearn.model_selection import train_test_split x_train, x_test, y_train, y_test = train_test_split(x,y,test_size = 0.3,random_state=1) # %% Naive bayes from sklearn.naive_bayes import GaussianNB nb = GaussianNB() nb.fit(x_train,y_train) nb.score(x_test,y_test) # %% test print("print accuracy of naive bayes algo: ",nb.score(x_test,y_test)) 

print accuracy of naive bayes algo: 0.935672514619883 

In [40]:

#%% confusion matrix y_pred = nb.predict(x_test) y_true = y_test from sklearn.metrics import confusion_matrix cm = confusion_matrix(y_true,y_pred) # %% cm visualization import seaborn as sns f, ax = plt.subplots(figsize =(5,5)) sns.heatmap(cm,annot = True,linewidths=0.5,linecolor="red",fmt = ".0f",ax=ax) plt.xlabel("y_pred") plt.ylabel("y_true") plt.show() 

In [41]:

import pandas as pd import matplotlib.pyplot as plt import numpy as np data = pd.read_csv("../input/classification/data.csv") #print(data.info()) #print(data.head()) #print(data.describe()) # %% data.drop(["id","Unnamed: 32"],axis=1,inplace=True) data.tail() # malignant = M kotu huylu tumor # benign = B iyi huylu tumor 

In [42]:

# %% M = data[data.diagnosis == "M"] B = data[data.diagnosis == "B"] # scatter plot plt.scatter(M.radius_mean,M.texture_mean,color="red",label="kotu",alpha= 0.3) plt.scatter(B.radius_mean,B.texture_mean,color="green",label="iyi",alpha= 0.3) plt.xlabel("radius_mean") plt.ylabel("texture_mean") plt.legend() plt.show() 

In [43]:

# %% data.diagnosis = [1 if each == "M" else 0 for each in data.diagnosis] y = data.diagnosis.values x_data = data.drop(["diagnosis"],axis=1) # %% # normalization x = (x_data - np.min(x_data))/(np.max(x_data)-np.min(x_data)) 

In [44]:

# %% train test split from sklearn.model_selection import train_test_split x_train, x_test,y_train, y_test = train_test_split(x,y,test_size = 0.15,random_state = 42) #%% from sklearn.tree import DecisionTreeClassifier dt = DecisionTreeClassifier() dt.fit(x_train,y_train) print("score: ", dt.score(x_test,y_test)) 

score: 0.9302325581395349 

In [45]:

#%% confusion matrix y_pred = dt.predict(x_test) y_true = y_test from sklearn.metrics import confusion_matrix cm = confusion_matrix(y_true,y_pred) # %% cm visualization import seaborn as sns f, ax = plt.subplots(figsize =(5,5)) sns.heatmap(cm,annot = True,linewidths=0.5,linecolor="red",fmt = ".0f",ax=ax) plt.xlabel("y_pred") plt.ylabel("y_true") plt.show() 

In [46]:

import pandas as pd import matplotlib.pyplot as plt import numpy as np data = pd.read_csv("../input/classification/data.csv") #print(data.info()) #print(data.head()) #print(data.describe()) # %% data.drop(["id","Unnamed: 32"],axis=1,inplace=True) data.tail() # malignant = M kotu huylu tumor # benign = B iyi huylu tumor 

In [47]:

# %% M = data[data.diagnosis == "M"] B = data[data.diagnosis == "B"] # scatter plot plt.scatter(M.radius_mean,M.texture_mean,color="red",label="kotu",alpha= 0.3) plt.scatter(B.radius_mean,B.texture_mean,color="green",label="iyi",alpha= 0.3) plt.xlabel("radius_mean") plt.ylabel("texture_mean") plt.legend() plt.show() 

In [48]:

# %% data.diagnosis = [1 if each == "M" else 0 for each in data.diagnosis] y = data.diagnosis.values x_data = data.drop(["diagnosis"],axis=1) # %% # normalization x = (x_data - np.min(x_data))/(np.max(x_data)-np.min(x_data)) 

In [49]:

# %% train test split from sklearn.model_selection import train_test_split x_train, x_test,y_train, y_test = train_test_split(x,y,test_size = 0.15,random_state = 42) #%% random forest from sklearn.ensemble import RandomForestClassifier rf = RandomForestClassifier(n_estimators = 100,random_state = 1) rf.fit(x_train,y_train) print("random forest algo result: ",rf.score(x_test,y_test)) 

random forest algo result: 0.9534883720930233 

In [50]:

#%% confusion matrix y_pred = rf.predict(x_test) y_true = y_test from sklearn.metrics import confusion_matrix cm = confusion_matrix(y_true,y_pred) # %% cm visualization import seaborn as sns f, ax = plt.subplots(figsize =(5,5)) sns.heatmap(cm,annot = True,linewidths=0.5,linecolor="red",fmt = ".0f",ax=ax) plt.xlabel("y_pred") plt.ylabel("y_true") plt.show() 

Clustering

In [51]:

import numpy as np import pandas as pd import matplotlib.pyplot as plt # %% create dataset # class1 x1 = np.random.normal(25,5,1000) y1 = np.random.normal(25,5,1000) # class2 x2 = np.random.normal(55,5,1000) y2 = np.random.normal(60,5,1000) # class3 x3 = np.random.normal(55,5,1000) y3 = np.random.normal(15,5,1000) x = np.concatenate((x1,x2,x3),axis = 0) y = np.concatenate((y1,y2,y3),axis = 0) dictionary = {"x":x,"y":y} data = pd.DataFrame(dictionary) plt.scatter(x1,y1) plt.scatter(x2,y2) plt.scatter(x3,y3) plt.show() 

In [52]:

# %% KMEANS from sklearn.cluster import KMeans wcss = [] for k in range(1,15): kmeans = KMeans(n_clusters=k) kmeans.fit(data) wcss.append(kmeans.inertia_) plt.plot(range(1,15),wcss) plt.xlabel("number of k (cluster) value") plt.ylabel("wcss") plt.show() 

In [53]:

#%% k = 3 icin modelim kmeans2 = KMeans(n_clusters=3) clusters = kmeans2.fit_predict(data) data["label"] = clusters plt.scatter(data.x[data.label == 0 ],data.y[data.label == 0],color = "red") plt.scatter(data.x[data.label == 1 ],data.y[data.label == 1],color = "green") plt.scatter(data.x[data.label == 2 ],data.y[data.label == 2],color = "blue") plt.scatter(kmeans2.cluster_centers_[:,0],kmeans2.cluster_centers_[:,1],color = "yellow") plt.show() 

In [54]:

import numpy as np import pandas as pd import matplotlib.pyplot as plt # %% create dataset # class1 x1 = np.random.normal(25,5,100) y1 = np.random.normal(25,5,100) # class2 x2 = np.random.normal(55,5,100) y2 = np.random.normal(60,5,100) # class3 x3 = np.random.normal(55,5,100) y3 = np.random.normal(15,5,100) x = np.concatenate((x1,x2,x3),axis = 0) y = np.concatenate((y1,y2,y3),axis = 0) dictionary = {"x":x,"y":y} data = pd.DataFrame(dictionary) plt.scatter(x1,y1,color="black") plt.scatter(x2,y2,color="black") plt.scatter(x3,y3,color="black") plt.show() 

In [55]:

# %% dendogram from scipy.cluster.hierarchy import linkage, dendrogram merg = linkage(data,method="ward") dendrogram(merg,leaf_rotation = 90) plt.xlabel("data points") plt.ylabel("euclidean distance") plt.show() 

In [56]:

# %% HC from sklearn.cluster import AgglomerativeClustering hiyerartical_cluster = AgglomerativeClustering(n_clusters = 3,affinity= "euclidean",linkage = "ward") cluster = hiyerartical_cluster.fit_predict(data) data["label"] = cluster plt.scatter(data.x[data.label == 0 ],data.y[data.label == 0],color = "red") plt.scatter(data.x[data.label == 1 ],data.y[data.label == 1],color = "green") plt.scatter(data.x[data.label == 2 ],data.y[data.label == 2],color = "blue") #plt.scatter(data.x[data.label == 3 ],data.y[data.label == 3],color = "black") plt.show() 

Other Content

)

In [57]:

import pandas as pd # %% import twitter data data = pd.read_csv("../input/natural-language-process-nlp/gender-classifier.csv",encoding = "latin1") data = pd.concat([data.gender,data.description],axis=1) data.dropna(axis = 0,inplace = True) data.gender = [1 if each == "female" else 0 for each in data.gender] print(data.info()) print(data.head()) #print(data.describe()) 

<class 'pandas.core.frame.DataFrame'> Int64Index: 16224 entries, 0 to 20049 Data columns (total 2 columns): gender 16224 non-null int64 description 16224 non-null object dtypes: int64(1), object(1) memory usage: 380.2+ KB None gender description 0 0 i sing my own rhythm. 1 0 I'm the author of novels filled with family dr... 2 0 louis whining and squealing and all 3 0 Mobile guy. 49ers, Shazam, Google, Kleiner Pe... 4 1 Ricky Wilson The Best FRONTMAN/Kaiser Chiefs T... 

In [58]:

import nltk # natural language tool kit #nltk.download("stopwords") # corpus diye bir kalsore indiriliyor from nltk.corpus import stopwords # sonra ben corpus klasorunden import ediyorum import re description_list = [] for description in data.description: description = re.sub("[^a-zA-Z]"," ",description) # regular expression RE mesela "[^a-zA-Z]" description = description.lower() # buyuk harftan kucuk harfe cevirme description = nltk.word_tokenize(description)# split kullanırsak "shouldn't " gibi kelimeler "should" ve "not" diye ikiye ayrılmaz ama word_tokenize() kullanirsak ayrilir description = [ word for word in description if not word in set(stopwords.words("english"))] # greksiz kelimeleri cikar lemma = nltk.WordNetLemmatizer() # lemmatazation loved => love gitmeyecegim = > git description = [ lemma.lemmatize(word) for word in description] description = " ".join(description) description_list.append(description) #print(description_list) 

In [59]:

# %% bag of words from sklearn.feature_extraction.text import CountVectorizer # bag of words yaratmak icin kullandigim metot max_features = 5000 count_vectorizer = CountVectorizer(max_features=max_features,stop_words = "english") sparce_matrix = count_vectorizer.fit_transform(description_list).toarray() # x #print("en sik kullanilan {} kelimeler: {}".format(max_features,count_vectorizer.get_feature_names())) 

In [60]:

# %% y = data.iloc[:,0].values # male or female classes x = sparce_matrix # train test split from sklearn.model_selection import train_test_split x_train, x_test, y_train, y_test = train_test_split(x,y, test_size = 0.1, random_state = 42) 

In [61]:

# %% naive bayes from sklearn.naive_bayes import GaussianNB nb = GaussianNB() nb.fit(x_train,y_train) #%% prediction y_pred = nb.predict(x_test) print("accuracy: ",nb.score(y_pred.reshape(-1,1),y_test)) 

accuracy: 0.48120764017252005 

)

In [62]:

from sklearn.datasets import load_iris import pandas as pd # %% iris = load_iris() feature_names = iris.feature_names y = iris.target data = pd.DataFrame(iris.data,columns = feature_names) data["sinif"] = y x = iris.data print(data.info()) print(data.head()) #print(data.describe()) 

<class 'pandas.core.frame.DataFrame'> RangeIndex: 150 entries, 0 to 149 Data columns (total 5 columns): sepal length (cm) 150 non-null float64 sepal width (cm) 150 non-null float64 petal length (cm) 150 non-null float64 petal width (cm) 150 non-null float64 sinif 150 non-null int64 dtypes: float64(4), int64(1) memory usage: 5.9 KB None sepal length (cm) sepal width (cm) ... petal width (cm) sinif 0 5.1 3.5 ... 0.2 0 1 4.9 3.0 ... 0.2 0 2 4.7 3.2 ... 0.2 0 3 4.6 3.1 ... 0.2 0 4 5.0 3.6 ... 0.2 0 [5 rows x 5 columns] 

In [63]:

#%% PCA from sklearn.decomposition import PCA pca = PCA(n_components = 2, whiten= True ) # whitten = normalize pca.fit(x) x_pca = pca.transform(x) print("variance ratio: ", pca.explained_variance_ratio_) print("sum: ",sum(pca.explained_variance_ratio_)) 

variance ratio: [0.92461872 0.05306648] sum: 0.977685206318795 

In [64]:

#%% 2D data["p1"] = x_pca[:,0] data["p2"] = x_pca[:,1] color = ["red","green","blue"] import matplotlib.pyplot as plt for each in range(3): plt.scatter(data.p1[data.sinif == each],data.p2[data.sinif == each],color = color[each],label = iris.target_names[each]) plt.legend() plt.xlabel("p1") plt.ylabel("p2") plt.show() 

In [65]:

from sklearn.datasets import load_iris import pandas as pd import numpy as np #%% iris = load_iris() x = iris.data y = iris.target data = pd.DataFrame(iris.data,columns = feature_names) data["sinif"] = y print(data.info()) print(data.head()) #print(data.describe()) # %% normalization x = (x-np.min(x))/(np.max(x)-np.min(x)) 

<class 'pandas.core.frame.DataFrame'> RangeIndex: 150 entries, 0 to 149 Data columns (total 5 columns): sepal length (cm) 150 non-null float64 sepal width (cm) 150 non-null float64 petal length (cm) 150 non-null float64 petal width (cm) 150 non-null float64 sinif 150 non-null int64 dtypes: float64(4), int64(1) memory usage: 5.9 KB None sepal length (cm) sepal width (cm) ... petal width (cm) sinif 0 5.1 3.5 ... 0.2 0 1 4.9 3.0 ... 0.2 0 2 4.7 3.2 ... 0.2 0 3 4.6 3.1 ... 0.2 0 4 5.0 3.6 ... 0.2 0 [5 rows x 5 columns] 

In [66]:

# %% train test split from sklearn.model_selection import train_test_split x_train, x_test, y_train, y_test = train_test_split(x,y,test_size = 0.3) # knn model from sklearn.neighbors import KNeighborsClassifier knn = KNeighborsClassifier(n_neighbors = 13) # n_neighbors = k # %% K fold CV K = 10 from sklearn.model_selection import cross_val_score accuracies = cross_val_score(estimator = knn, X = x_train, y= y_train, cv = 10) print("average accuracy: ",np.mean(accuracies)) print("average std: ",np.std(accuracies)) knn.fit(x_train,y_train) print("test accuracy: ",knn.score(x_test,y_test)) 

average accuracy: 0.9805555555555555 average std: 0.03938179688543842 test accuracy: 0.9555555555555556 

In [67]:

#Model Selection grid search cross validation for knn from sklearn.model_selection import GridSearchCV grid = {"n_neighbors":np.arange(1,50)} knn= KNeighborsClassifier() knn_cv = GridSearchCV(knn, grid, cv = 10) # GridSearchCV knn_cv.fit(x,y) #%% print hyperparameter KNN algoritmasindaki K degeri print("tuned hyperparameter K: ",knn_cv.best_params_) print("tuned parametreye gore en iyi accuracy (best score): ",knn_cv.best_score_) 

tuned hyperparameter K: {'n_neighbors': 13} tuned parametreye gore en iyi accuracy (best score): 0.98 

In [68]:

#Model Selection Grid search CV with logistic regression x = x[:100,:] y = y[:100] from sklearn.linear_model import LogisticRegression grid = {"C":np.logspace(-3,3,7),"penalty":["l1","l2"]} # l1 = lasso ve l2 = ridge logreg = LogisticRegression() logreg_cv = GridSearchCV(logreg,grid,cv = 10) logreg_cv.fit(x,y) print("tuned hyperparameters: (best parameters): ",logreg_cv.best_params_) print("accuracy: ",logreg_cv.best_score_) 

tuned hyperparameters: (best parameters): {'C': 0.1, 'penalty': 'l2'} accuracy: 1.0 

In [69]:

import pandas as pd import os print(os.listdir("../input/movielens-20m-dataset/")) # import movie data set and look at columns movie = pd.read_csv("../input/movielens-20m-dataset/movie.csv") print(movie.columns) movie = movie.loc[:,["movieId","title"]] movie.head(10) 

['link.csv', 'genome_tags.csv', 'movie.csv', 'genome_scores.csv', 'tag.csv', 'rating.csv'] Index(['movieId', 'title', 'genres'], dtype='object') 

In [70]:

# import rating data and look at columsn rating = pd.read_csv("../input/movielens-20m-dataset/rating.csv") print(rating.columns) # what we need is that user id, movie id and rating rating = rating.loc[:,["userId","movieId","rating"]] rating.head(10) 

Index(['userId', 'movieId', 'rating', 'timestamp'], dtype='object') 

In [71]:

# then merge movie and rating data data = pd.merge(movie,rating) # now lets look at our data data.head(10) print(data.shape) data = data.iloc[:1000000,:] # lets make a pivot table in order to make rows are users and columns are movies. And values are rating pivot_table = data.pivot_table(index = ["userId"],columns = ["title"],values = "rating") pivot_table.head(10) 

(20000263, 4) 

In [72]:

movie_watched = pivot_table["Bad Boys (1995)"] similarity_with_other_movies = pivot_table.corrwith(movie_watched) # find correlation between "Bad Boys (1995)" and other movies similarity_with_other_movies = similarity_with_other_movies.sort_values(ascending=False) similarity_with_other_movies.head() 

Content

Cleaning Data

• Diagnose data for cleaning
• Exploratory data analysis (EDA)
• Visual exploratory data analysis
• Tidy data
• Pivoting data
• Concatenating data
• Data types
• Missing data and testing with assert

Manipulating Data Frames with Pandas

• Index objects and labeled data
• Hierarchical indexing
• Pivoting data frames
• Stacking and unstacking data frames
• Melting data frames
• Categoricals and groupby

Seaborn

• Bar Plot
• Point Plot
• Joint Plot
• Pie Plot
• Lm Plot
• Kde Plot
• Violin Plot
• Heatmap
• Box Plot
• Swarm Plot
• Pair Plot
• Count Plot

Plotly

• Line Plot
• Scatter Plot
• Bar Plot
• Pie Plot
• Bubble Plot
• Histogram
• Word Cloud
• Box Plot
• Scatter Plot Matrix
• Inset Plot
• 3D Scatter Plot
• Multiple Subplots
• Animation Plot

Visualization Tools

• Parallel Plots (Pandas)
• Network Charts (networkx)
• Venn Diagram (matplotlib)
• Donut Plot (matplotlib)
• Spyder Chart (matplotlib)
• Cluster Map (seaborn)

You can check my Kaggle profile for details and codes

Gezgin Satıcı Problemi

GSP, n adet şehir arasındaki mesafelerin bilindiği durumda, şehirlerin her birine yalnız bir kez uğramak şartıyla, başlangıç noktasına geri dönülmesi esasına dayalı, tur boyunca kat edilen toplam yolun en kısa olduğu şehir sıralamasının (optimal rota) bulunmasının amaçlandığı bir problemdir. Dağıtım, rotalama, kuruluş yeri belirleme, planlama, lojistik gibi problemlerde geniş bir uygulama alanına sahip olan gezgin satıcı problemi, aynı zamanda optimizasyon alanında, araştırmacılar tarafından üzerinde uzun yıllardır çalışmalar yapılan NP-hard (çözümü zor) sınıfında yer alan bir problemdir.

Tavlama Benzetimi Algoritması (TB)

TB algoritması, ilk olarak 1983 yılında Kirkpatrick, Gelatt ve Vecchi tarafından sunulmuş olup, optimizasyon problemlerinin çözümü için geliştirilmiş bir yerel arama algoritmasıdır.

TB algoritması adını erimiş metalin soğutulması işlemi olan, tavlama işleminden almaktadır. Bu işlemde metalik yapıdaki kusurları azaltmak için bir materyal ısıtılır, daha büyük kristal boyuta ve minimum enerji ile katı kristal duruma yavaşça soğutulur. Tavlama işlemi, sıcaklığın ve soğuma katsayısının dikkatlice kontrolünü gerektirir. Tavlama işlemi sonucunda oluşan kristalleşme, metalin mekanik özelliklerini iyileştiren moleküler yapısındaki değişikliklerle oluşmaktadır. Tavlama işlemindeki ısının davranışı, optimizasyondaki kontrol parametresiyle aynı gibi görülür. Isının, daha iyi sonuçlara doğru algoritmaya rehberlik eden bir rolü vardır. Bu durum ancak kontrollü bir tutum içinde, ısının kademeli olarak düşürülmesiyle yapılabilir. Eğer ısı aniden düşürülürse, algoritma lokal minimum ile durur.

TB algoritması; birçok değişkene sahip fonksiyonların maksimum veya minimum değerlerinin bulunması için, özellikle de
birçok yerel minimuma sahip doğrusal olmayan fonksiyonların minimum değerlerinin bulunması için tasarlanmıştır.
Tavlama benzetimi algoritmasında; sıcaklık, sıcaklığın düşürülmesi, tekrar işlemi (döngü) gibi parametreler vardır. Algoritmada bir başlangıç aday çözümü belirlenip, bu çözüm başlangıçta en iyi çözüm olarak kabul edilir. Başlangıç aday çözümünün kopyasına "tweak" işlemi (başlangıç aday çözümüne ufak bir değişiklik yaparak yeni bir çözüm
üretme işlemi) uygulanır. Daha sonra ki adımlar da ise en iyi çözüm kabul edilen başlangıç aday çözümü ile yeni üretilen çözümün hangisinin daha iyi olduğu (kaliteleri) veya 0-1 arasında üretilen bir rassal sayının < 𝑒 ((Kalite(Y)− Kalite(B))/sıcaklık) durumu araştırılır. Eğer yeni sonuç daha iyi ise en iyi çözüm olarak yeni çözüm atanır. Sıcaklık
parametresi, tavlama yönteminde başlangıçta belirlenen bir değerdir. Bu değer, oluşturulan döngünün sonunda, belirli bir oranda (sıcaklığın düşürülme parametresi kadar) azaltılır. Bu işlemler en iyi çözüm bulunana kadar veya algoritmanın çalıştırılması için belirlenen bir süre bitene kadar veya sıcaklık parametresi sıfır veya sıfırdan küçük olana kadar sürdürülebilir.

Tabu Arama Algoritması (TA)

Glover tarafından ortaya atılan ve Hansen tarafından türetilmiş versiyonları bulunan TA algoritması, temelde son çözüme götüren adımın dairesel hareketler oluşturmasını engellemek için cezalandırılarak bir sonraki döngüde tekrar edilmesinin yasaklanması üzerine kurgulanmıştır.

TA algoritması döngü ya da çalışma süresi boyunca üretilen çözümler ile ilgili bilgileri saklamak üzere tasarlanmış dinamik bir hafızaya sahiptir. Tabu listesi olarak da adlandırılan bu hafızada saklanan bilgiler, araştırma uzayında yeni çözüm kümelerinin oluşturulması için kullanılır. TA algoritması, mevcut çözümlerden küçük bir değişim ile (tweak) elde ettiği denenmemiş bir çözüm kümesi üreterek optimizasyona
başlamaktadır. TA algoritmasında, çözüm uzayında bir yerel minimum noktada takılmayı engelleyebilmek için oluşturulan yeni çözüme, o anki çözümden daha kötü olsa bile müsaade edilmektedir. Ancak kötü çözüme izin verilmesi algoritmayı bir kısır döngü içerisine sokabilecektir. Algoritmanın kısır döngüye girmesine engel olmak için, bir tabu listesi oluşturulur ve o anki çözüme uygulanmasına izin verilmeyen tüm yasaklı hareketler tabu listesinde saklanır.

Bir hareketin tabu listesine alınıp alınmayacağını belirlemek için, tabu kısıtlamaları adı verilen bazı kriterler kullanılmaktadır. Tabu listesinin kullanılması, belirli bir iterasyon sayısınca daha önce denenmiş çözümlerin tekrar edilmesini engellediği için arama
esnasında bir bölgede takılma ihtimalini azaltmaktadır. TA, mümkün bir çözüm ile başlar. Bu çözüm, problemin matematiksel ifadesinde geçen kısıtları tatmin eden bir çözümdür. Tabu aramanın performansı başlangıç çözümüne bağlıdır. Bu nedenle mümkün olduğunca iyi olan bir çözüm ile başlamak gerekir. Tabu listesi ilk giren ilk çıkar (first in first out = FIFO) mantığında çalışan bir listedir. Algoritmada belirlenen karakteristik özelliklere göre tabu listesi sürekli olarak yukarıdan doldurulmaya başlar. Bulunan elemanların sayısı liste uzunluğunu aştığında yeni gelen elemanın listeye eklenmesi için listenin en sonundaki eleman listeden çıkarılır.

Konuyla ilgili yapılan çalışmanın kodları Github'dan inceleyebilirsiniz. Kodlar arasında yorum satırlarıyla konu hakkında fikir sahibiyseniz anlaşılır olacaktık.

Github Kodu: https://github.com/bulentsiyah/Tavlama-Benzetimi-ve-Tabu-Arama-Algoritmalari-ile-Gezgin-Satici-Problemi

Bu kıyaslama için korelasyon methodu kullanılır. Uygulamada ilk olarak eğitim hareketleri girilerek kıyas yapılacak hareketler oluşturulur. Daha sonra test hareketine başlanır, hareket tamamlandığında uygulamaki tüm eğitim hareketleri ile her düzlemde(x,y,z) korelasyon katsayıları ölçülür. En yüksek ve belirlediğimiz eşiği aşan değere sahip olan eğitim hareketi tanımı, test hareketinin tanımamızı sağlar. Bu hareket harf, şekil veya cümle gibi sözcük öbekleri olabilir. Burada hedef işlem başından sonuna yapılan hareketin daha önceden tanımlanmış bir harekete benzetmektir.

Proje teknik terimler
Korelasyon, olasılık kuramı ve istatistikte iki rassal değişken arasındaki doğrusal ilişkinin yönünü ve gücünü belirtir. Genel istatistiksel kullanımda korelasyon, bağımsızlık durumundan ne kadar uzaklaşıldığını gösterir.
Korelasyon katsayısı, bağımsız değişkenler arasındaki ilişkinin yönü ve büyüklüğünü belirten katsayıdır. Bu katsayı, (-1) ile (+1) arasında bir değer alır. Pozitif değerler direk yönlü doğrusal ilişkiyi; negatif değerler ise ters yönlü bir doğrusal ilişkiyi belirtir. Korelasyon katsayısı 0 ise söz konusu değişkenler arasında doğrusal bir ilişki yoktur.

Jiroskop, (İngilizce: Gyroscope, Gyro) veya Yalpalık, Cayroskop, Cayro, yön ölçümü veya ayarlamasında kullanılan, açısal dengenin korunması ilkesiyle çalışan bir alet. Jiroskopik hareketin temeli fizik kurallarına ve açısal momentumun korunumu ilkesine dayalıdır.

Github Kodu: https://github.com/bulentsiyah/Android_Jiroskop_Sensoru_ile_Hareket_Tanima

Tüm projeyi İNDİR: Program Rapor ve Kodu

1. GİRİŞ

Bu çalışmada, çift taraflı mondaj hattının her iki tarafı için belirlenmiş çevrim süresi içerisinde istasyon sayısını en aza indirgeme amaçlanmıştır. Operasyonlarda taraf ve istasyon sayısı kısıtları bulunmaktadır. Problemin Genetik Algortima ile çözümü için geliştirilen uygulama, c#(sharp) programlama dili ile yazılmıştır.

Genetik algoritma rastgele arama metodu olduğu için tek bir çözüm aramak yerine bir çözüm kümesi üzerinde çalışır. Optimum çözüme olası çözümlerin bir bölümü üzerinde gidilir. Böylece çalışmadaki sonuçlar her zaman en iyi olmaz. Çalışmada genetik algoritmanın kullanılmasının nedeni, genetik algoritmanın problemin doğasıyla ilgili herhangi bir bilgiye ihtiyaç duymamasıdır.

2. Materyal ve Yöntem

Genetik Algoritmalar, daha iyi çözümlere yavaş yavaş bir yaklaşım sağlayan geniş bir problem uzayı boyunca yönlendirilmiş rastgele bir araştırmaya imkan sağlar. Temel avantajı optimize edilmeye çalışılan problemin doğasıyla ilgili herhangi bir bilgiye ihtiyaç göstermemeleridir.

2.1. GENETİK ALGORİTMALARIN TEMEL KAVRAMLARI

Evrimsel hesaplama topluluğunda yerleşik, tek bir Genetik Algoritma tanımı bulunmamakla beraber, Genetik Algoritma sınıfına girdiği kabul edilen yöntemlerde en azından şu ortak unsurlara rastlanır: kromozom topluluğu, uygunluğa göre seçilim, yeni bireyler üretmek için çaprazlama, yeni bireylerin rastgele mutasyonu. Holland'ın GA'nın unsurları içinde saydığı ters çevirme operatörü günümüzde nadiren kullanılmaktadır.

2.1.1. Kromozom ve Topluluk

GA'da kromozomlar, problem için olası çözümleri temsil ederler. Bu çözümlerden her birine birey adı verilir. Topluluk (popülasyon) kromozomlardan (bireylerden) oluşan kümedir. GA'nın kromozom toplulukları üzerinde işlemler yapması ile, bir önceki topluluklar her seferinde yeni üretilen topluluklarla yer değiştirir.

2.1.2. Uygunluk

Uygunluk değeri, çözümün kalitesini belirler ve uygunluk fonksiyonu kullanılarak hesaplanır. Uygunluk fonksiyonu mevcut topluluktaki her kromozoma bir puan (uygunluk değeri) atar. Kromozomun uygunluğu, o kromozomun eldeki problemi ne kadar iyi çözdüğüyle ilişkilidir.

2.1.3. Genetik Operatörler

GA'nın en basit formu üç tip genetik operatör içerir: seçilim, çaprazlama (çift noktalı) ve mutasyon.
Seçilim: Bu operatör topluluktaki kromozomları üreme için seçer. Kromozomun yüksek uygunluk değerine sahip olması, üremek için seçilmesi ihtimalini arttırır.
Çaprazlama: Bu operatör rastgele iki lopus belirleyip, iki kromozomun bu lopuslardan önceki ve sonraki kısımlarını aynı kalıcak şeklide, lopus aralarındaki kısımları değiştirilerek gerçekleştirilir.
Mutasyon: Bu operatör kromozomdaki bir veya daha fazla rastgele alınan bireyin yine rastgele seçilen gen ile genin değerine sahip diğer genin değişimi ile olur.

2.2. GENETİK ALGORİTMA PARAMETRELERİ

2.2.1. Topluluk Büyüklüğü

Topluluk büyüklüğü için seçilen değer, algoritmanın performansını iki şekilde etkilemektedir. Birincisi, topluluk büyüklüğünün aşırı küçülmesi araştırma uzayının yetersiz örneklenmesine sebep olacağından
kontrollü ıraksamayı sağlamak zorlaşacak ve araştırma belirli bir alt optimal noktaya doğru sürüklenecektir. ikincisi, topluluk için aşırı yüksek değer seçildiğinde bir nesillik gelişim oldukça uzun süreye ihtiyaç duymaktadır.

2.2.2. Çaprazlama Oranı

Bireylerin çoğalması sırasında kromozomlara uygulanacak çaprazlama operatörünün frekansını belirlemek amacıyla kullanılan parametredir. Düşük çaprazlama oranı yeni nesle çok az sayıda yeni yapının (ebeveyninden farklı yeni bireyler) girmesine sebep olmaktadır. Dolayısıyla tekrar üreme operatörü algoritmada aşırı etkili bir operatör haline gelmekte ve araştırmanın yakınsama hızı düşmektedir. Yüksek çaprazlama oranı araştırma uzayının çok hızlı bir şekilde araştırılmasına sebep olmaktadır. Ama oran aşırı yüksek ise, çaprazlama operatörü
benzer veya daha iyi yapıları üretmeden kuvvetli olan yapılar çok hızlı olarak bozulduğundan, algoritmanın performansı düşmektedir.

2.2.3. Mutasyon Oranı

Mutasyon operasyonun frekansı, etkili bir genetik algoritma tasarlamak için çok iyi kontrol edilmelidir. Mutasyon operasyonu, araştırma sahasına yeni bölgelerin girmesini sağlar. Yüksek mutasyon oranı, araştırmaya aşırı bir rastgelelik kazandıracak ve araştırmayı çok hızlı olarak ıraksatacaktır. Başka bir deyişle, topluluğun gelişmesine değil tahribatına sebep olacaktır. Bu durumun tersine, çok düşük mutasyon oranının kullanılması ıraksamayı aşırı düşürecek ve araştırma uzayının tamamen araştırılmasını engelleyecektir. Dolayısıyla, algoritmanın alt optimal çözüm bulmasına sebep olacaktır.

2.3. GENETİK ALGORİTMA SÜRECİ

Çözülmek üzere tanımlı bir problem verilmesi ve aday çözümlerin birer sayı dizisi ile temsil edilmesi halinde, GA şu şekilde çalışır:
1. N adet kromozom (problem için aday çözümler) içeren rastgele oluşturulmuş bir topluluk ile başla.
2. Topluluktaki her x kromozomu için f(x) uygunluk değerini hesapla.
3. Aşağıdaki adımları birey n (topluluk büyüklüğü) oluşturuluncaya kadar tekrarla.
3.a. Güncel topluluktan, yüksek uygunluk değerinin seçilme ihtimalini arttırdığını göz önünde bulundurarak, iki ebeveyn kromozom seç. Seçilim, aynı kromozomun birden çok defa ebeveyn olarak seçilmesine olanak verecek şekilde yapılır.
3.b. Pc olasılığı ("çaprazlama olasılığı" ya da "çaprazlama oranı") ile seçilen çifti iki yeni birey oluşturmak üzere rastgele belirlenen iki noktadan çaprazla. Eğer çaprazlama gerçekleşmezse ebeveynlerinin birebir kopyası olan iki çocuk oluştur. Pc için iki noktalı çaprazlama yöntemi seçilmiştir.
3.c. Pm olasılığı ("mutasyon olasılığı" ya da "mutasyon oranı") ile, oluşan bir veya birden fazla çocuğu tüm veya bazı lopuslarında mutasyona uğrat. Lopuslardaki genlerin değiştirilmesi ile de mutasyon gerçekleştirilir.
3.d. Sonuçta elde edilen kromozomları yeni topluluğa ekle.
4. Önceki topluluğu yeni topluluk ile değiştir. Böylece yeni nesil elde edilmiş oldu.
5. Sonlandırma koşulu sağlandıysa mevcut topluluktaki en iyi çözümü döndür, sağlanmadıysa 2. adıma dön. Sonlandırma koşulu çoğu zaman nesil sayısıdır. Bazı genetik algortimalarda bu koşul, belirlenen aralıkta uygunluk değerine sahip birey elde edilmesi olabilir.

2.4. SÜRECİN PROBLEME UYGULANIŞI

2.4.1. İlk Toplum Oluşturulması ve Kromozomların Kodlanması

Bir GA programının yazılması işleminde karşılaşılan ilk problemlerden biri kromozomların kodlanmasıdır. Kodlama işlemi problemin türüne göre değişmektedir. Bazen binary (ikili) kodlama en iyi çözüm bulmada kullanılırken, bazen de permutasyon veya değer kodlama yöntemleri optimum sonucu bulmada en uygun kodlama yöntemi olabilir. Permutasyon kodlama yöntemi, genel olarak gezgin satıcı ve şebeke tasarımları gibi sıra gözeten problemlerde yaygınca kullanılır.

Problemin çözümü için populasyon büyüklüğü karar verilmeli, populasyon büyüklüğü seçilirken aşırı yüksek seçilirse gelişim yavaşlar, aşırı küçük seçilmesi durumunda da araştırma uzayı yetersiz olucağından problemimize en uygun populasyon büyüklüğü 30 birey olarak seçilmiştir. Programın arayüzünde birey sayısı değiştirilebilir. Problemde permutasyon kodlama yöntemi seçilip, hatların taraflarındaki operasyon sayıları farklı olduğundan, hattın sol tarafı 10 operasyon dolayısıyla 10 gen ile, hattın sağ tarafı 17 operasyon yani 17 gen ile temsil edilmiştir. Her gendeki sayı değeri operasyon numarasına eşittir. Örnek olarak hattın sol tarafındaki 7 nolu kromozomun genleri: 4051296741038 şeklinde kodlanmıştır.

İlk toplum oluşturulurken tüm bireylerin genleri rastgele oluşturulmuştur. Problemde ilk toplumu oluşturan fonksiyon sadece ilk nesilde çalışır. Diğer nesillerde zaten eski ve yeni nesil değişimi gerçekleştiğinden bu fonksiyon kullanılmaz. Fonksiyon, birey sayısı kadar dönen döngüde her birey için gerekli gen sayısı kadar rastgele sayı üretir. Permutasyon kodlama ile yapılırken aynı gen değerine sahip bireylerin oluşması engellenmiştir.

2.4.2. Toplumdaki Her Kromozomun Uygunluk Değerinin Ölçülmesi

Popülasyon içerisinde yer alan ve her bir bireyi temsil eden kromozomların ne kadar iyi olduklarını bulan fonksiyona uygunluk fonksiyonu (uyumluluk, fitness) fonksiyonu denir. Bu GA programında özel çalışan tek kısımdır. Uygunluk fonksiyonu kromozomların şifrelerini çözer (decoding) ve sonra da hesaplama yaparak bu kromozomların uygunluklarını hesaplar.Elde edilen uygunluk değerlerine göre kromozomların yeni generasyon da olup olmayacaklarına karar verilir. Bütün popülasyonun (topluluğun) uygunluk değerleribelirlendiğinde sonuçlandırma kriterinin sağlanıp sağlanmadığına bakılır. Sonuçlandırma kriteri birkaç şekilde seçilebilmektedir. Bu seçeneklerden biri, istenilen nesil sayısına ulaşılması olabileceği gibi, tüm topluluğun uygunluk değerinin en iyi çözümün uyumluluk değerine oranının yeterli görülen bir değere ulaşması olabilir.

Uygunluk değerleri şöyle hesaplanır. Genler operasyonları temsil edip, sıra ile gruplandırılarak işçinin net çalışma süresi(260 dk.) ile işlemlerden geçirilip, kayıp zaman bulunarak hesaplanır. Buradaki gruplam için şart belli bir eşik değere göre yapılır. Eşik değeri sağlayan operasyonlar yani genler aynı grupta yer alarak o istasyona atanır. İşçinin çalışma süresi ile işlemler şunlardır. Eşik değeri sağlayan gen grubunun tüm süreleri toplanır. Bu toplam değer işçinin çalışma süresine göre modu alınır. Alınan mod ile elde edilen değer kalan değeridir. Toplam değer yine işçinin çalışma süresine göre normal bölme işleminden geçirilir. İşlem sonucunda elde edilen değer bölüm değerdir. Uygunluk değeri için ilk olarak işçinin çalışma süresi ile elde edilen kalan değer çıkartılır. Bu değer, elde edilen bölüm süresinin bir fazlası ile çarpılarak uygunluk değeri hesaplanır. İşlemlerde şu ayrıntı önemlidir. Eşik değeri geçememe ihtimali olursa tüm operasyonlar tek istasyonda toplanır. Bu istenmeyen durum için kayıp zaman, tüm operasyonların toplamı ile elde edilir. Böylece problemde bu adımda tekli gruplamanın uygunluk değeri yüksek olduğundan elenme ihtimali çok yükselir. Uygunluk fonksiyonunda eşik değer istenilirse her iki hattın tarafı için ayrı değerlere sahip olabilir. Fonksiyon sonrasında tüm bireylerin uygunluk değerleri bir dizide toplanır. Dizilerin birbirleriyle indexleri sayesinde anlaşırlar.

2.4.3. YENİ TOPLUM OLUŞTUR

2.4.3.1. Elitizm Yapılması

Elitizm, performansı en iyi bireyle (bireyler) temsil edilen o ana kadar ki en iyi çözümün korunarak, değiştirilmeksizin bir sonraki nesle aktarılmasını sağlar. Toplumda tüm bireyler çaprazlanarak oluşturulursa, iyi olan bireylerin yok olma veya çözümden uzaklaşma ihtimali ortaya çıkar. Bu durumu ortadan kaldırmak için toplum içindeki en iyi 2 tane birey direk yeni topluma eklenerek elitizm yapıldı. Elitizm yapıldığı fonksiyonda en iyi uygunluk değerine sahip bireylerin seçilmesi dışında tüm bireyler uygunluk değerlerine göre sıralandı. Böylece çarpazlama için seçilen bireylerin kıyaslama işlemleri daha kolay gerçekleştirildi.

2.4.3.2. Seçilim ve Çaprazlama

En iyi kromozomları seçmek için birçok yöntem vardır. Bu seçim yöntemlerinden bazıları; Rulet tekerleği seçimi (roulette wheel selection), Boltzman seçimi (Boltzman selection), turnuva seçimi (tournament selection), sıralama seçimi (rank selection) ve sabit durum seçimidir. Seçilimde ikili turnuva seleksiyonu kullanıldı. İkili turnuva seçiminde populasyon içinden rastgele iki birey seçilir ve uygunluklarına göre iyi olan alınır, daha sonra tekrar rastgele iki birey seçilir ve yine uygunluklarına göre en iyi olan alınır. Böylece finale kalan iki tane birey çaprazlama işlemi için seçilmiş olur.

Genel olarak çaprazlama işlemi; kromozomların nasıl kodlanacağı belirlendikten sonra popülasyondaki kromozomlardan uygunluk değeri yüksek olanlar içerisinden rasgele seçilen iki birey arasında, yine rasgele seçilen bir noktaya göre karşılıklı gen alış-verişi olarak tanımlanır. Çaprazlama işlemi, uygunluk değeri iyi olan ve rasgele seçilen iki kromozomdan daha iyi uygunluk değerine sahip, yeni kromozomların elde edilmesi amacıyla yapılmaktadır. Yeni neslin uygunluk değerlerinin iyi çıkması ve problemin optimum çözüme ulaşabilmesi açısından çaprazlama işlemi son derece önem taşımaktadır. Bu aşamada, faklı kromozomlar alınarak çaprazlama işlemi yapıldığı için değişik özelliklerin test edilmesine ve hızlı olarak yeniden oluşmasına olanak sağlar. Bu işlem neticesinde ise, iki bireyin kopyası durumundaki kopyalanmış bireyler ile çeşitlilik sağlanmış ve en iyi çözüme yaklaşım sağlanmıştır. Çaprazlama için uygulamada iki noktalı çaprazlama seçilmiştir. Bu tür çaprazlama işleminde iki tane kırılma noktası alınır. İlk noktaya kadar olan bitler birinci kromozomdan, iki nokta arasındaki bitler ikinci kromozomdan, kalanlar ise tekrar birinci kromozomdan yeni bireye kopyalanırlar.

Uygulamada seçilen ikili turnuva metodunu uygulamak için toplumda rastgele 2 şer birey alınıp birbirleriyle kıyaslanır. Bu kıyaslama işlemini, daha önce elitizm fonksiyonunda yapılmış olan bireylerin uygunluklarına göre sıralanmış olması kolaylaştırır. Çünkü rastgele elde edilen sayıların, sayı değerlerini kıyaslamak yeterli olacaktır. Çaprazlama için seçilen iki bireyler iki noktalı yöntem ile çaprazlanıp yeni topluma aktarılır.

2.4.3.3. Mutasyon

GA programının sonuca ulaşmasında önemli olan başka bir etkende mutasyon işlemidir. Programın belirli bir alana yoğunlaşarak sonuca ulaşmayı engelleyen bazı durumlarda, problemin daha geniş bir alanda arama yapabilmesi için mutasyon işlemine baş vurulur. Böylelikle popülasyondaki çözümlerin yerel optimuma düşmesi engellenmiş olur. Uygulamada çaprazlamaya uğrayan bireylerden biri mutasyona uğratıldı. Mutasyon için rastgele bir birey seçilir ve yine rastgele seçilen gen ile genin değerine sahip olan diğer gen yerdeğiştirilerek gerçekleştirilir.

2.4.4. ÖNCEKİ TOPLUM İLE YENİ TOPLUMU DEĞİŞTİR

Önceki topluluğu yeni topluluk ile değiştirilir. Böylece yeni nesil elde edilmiş olur.

2.4.5. SONLANDIRMA KOŞULU KONTROLU

Problemin çözümü için sonlandırma koşulu belirelenen iterasyon sayısı kabul edilir. Döngü sonlanınca problemin en uygun çözümü elde edilmiş olur.

3. PERFORMANS ANALİZİ

Çalışmada, çift taraflı mondaj hattının her iki tarafı için belirlenmiş çevrim süresi içerisinde istasyon sayısını en aza indirgeme hedeflenmiştir. Problemde her hattın belirli bir operasyon süresi vardır. Bu operasyonların bir araya geldiği istasyonlarda işlemleri gerçekleştirmek için operasyonların toplamı kadar süre harcanır. Bu süre bir işçinin çalışma süresinin tam katları şeklinde yerleştirilmelidir. Aksi durumda operasyonarın bitiminde işçinin bekleme yani kayıp süre oluşur. Bu uygulamada da amaç genetik algoritma ile bu süreyi olabildiğince en aza indirmek hedeflenmiştir.

3.1. OPERASYONLAR VE ÇEVRİM SÜRELERİ

Problemin tanımlanması için her istasyon için değişmez ve ayrı olan operasyon numaraları ile bu operasyonlara ait süreler tablo şeklinde verilmiştir.

3.2. PROBLEMİN VAROLAN DURUMU

İstasyonlar için şuan ki durum :