# Kontakt

<div align="left"><img src="/files/-LsRvCpqWLdP5Nr26IRh" alt=""></div>

{% hint style="warning" %}
Obecnie nie pracuję już na PW, materiały udostępnione w celach archiwalnych.
{% endhint %}

[dr Karol Jerzy Piczak](https://www.karolpiczak.com)\
Adiunkt, [Zakład Sztucznej Inteligencji](http://ai.ii.pw.edu.pl/), [Instytut Informatyki](http://ii.pw.edu.pl)

* <https://www.karolpiczak.com> &#x20;
* [~~karol.piczak@pw.edu.pl~~](mailto:karol.piczak@pw.edu.pl)  <karol@piczak.com>
* p. 26, gmach WEiTI (parter) &#x20;

## Konsultacje

*Nie prowadzę obecnie planowych konsultacji.*

## Dane kontaktowe

[Politechnika Warszawska](https://www.pw.edu.pl/)\
[Wydział Elektroniki i Technik Informacyjnych](https://www.pw.edu.pl/)\
ul. Nowowiejska 15/19\
00-665 Warszawa


# Prace dyplomowe

Proponowane i realizowane tematy prac dyplomowych.

## Tematyka prac

* sztuczne sieci neuronowe, uczenie maszynowe,
* klasyfikacja dźwięku,
* biologiczne inspiracje w sieciach neuronowych.

## Tematy obecnie realizowane przez dyplomantów

### \[MGR] Continual learning in audio classification tasks

### \[MGR] Plastyczność modeli sztucznych sieci neuronowych w uczeniu ciągłym

### \[MGR] Kompresja modeli klasyfikacji dźwięku

### ~~\[INŻ] Aplikacja internetowa do rozpoznawania progresji akordów za pomocą metod sztucznej inteligencji~~

### \[INŻ] **Aktywne uczenie modeli klasyfikacji dźwięku**

{% tabs %}
{% tab title="Zarys problemu" %}
Uczenie aktywne ([*active learning*](https://en.wikipedia.org/wiki/Active_learning_%28machine_learning%29)) jest formą uczenia maszynowego, w którym algorytm uczący może interaktywnie pytać użytkownika o etykiety dla wybranych przykładów. Ta forma jest szczególnie użyteczna, gdy dysponujemy zbiorem danych bez adnotacji, a koszt ręcznego etykietowania całego zbioru danych jest zbyt duży.
{% endtab %}

{% tab title="Cel i etapy pracy" %}
Celem pracy jest stworzenie prostej aplikacji webowej, która umożliwiałaby interaktywne uczenie modelu sztucznej sieci neuronowej, implementacja wybranego modelu klasyfikatora dźwiękowego oraz porównanie technik dobierania przykładów do interaktywnej adnotacji pod kątem uzyskiwanej oszczędności (liczby etykietowanych przykładów koniecznych do uzyskania oczekiwanej dokładności na zbiorze walidacyjnym).
{% endtab %}

{% tab title="Wykorzystywane narzędzia" %}

* **Języki programowania:** Python 3.7+, JavaScript/TypeScript
* **Biblioteki ML:** *Pytorch* lub *TensorFlow*
* **Frameworki:** *Flask* lub *Django* (ewentualnie [*Dash*](https://plotly.com/dash/))
* **Repozytorium kodu**: *GitHub.com* lub zakładowy *GitLab*&#x20;
* **Edycja pracy:** *LaTeX* (np. przez [Overleaf.com](https://www.overleaf.com/))&#x20;
* **Sprzęt:** W ramach zasobów Zakładu Sztucznej Inteligencji dostęp do systemu z GPU GeForce RTX 2080 Super (Ubuntu)
  {% endtab %}
  {% endtabs %}

### **\[INŻ] Klasyfikacja nagrań dźwiękowych ptaków za pomocą modeli ze skupianiem uwagi**

{% tabs %}
{% tab title="Zarys problemu" %}
Charakterystyczną cechą problemu klasyfikacji gatunków ptaków w nagraniach dźwiękowych jest niewielki udział użytecznego sygnału uczącego (poszczególnych wokalizacji) w stosunku do całości nagrania (zarówno w dziedzinie czasu, jak i częstotliwości). W takiej sytuacji jednym ze sposobów poprawy efektów uczenia sztucznych sieci neuronowych jest mechanizm skupiania uwagi ([*attention mechanism*](http://akosiorek.github.io/ml/2017/10/14/visual-attention.html)), który koncentruje sieć na najważniejszych fragmentach nagrania.
{% endtab %}

{% tab title="Cel i etapy pracy" %}
Celem pracy jest stworzenie systemu rozpoznawania gatunków ptaków w nagraniach dźwiękowych wykorzystującego sieci neuronowe z mechanizmem skupiania uwagi oraz zweryfikowanie działania systemu na przykładowych nagraniach. Potencjalnym rozszerzeniem pracy może być zgłoszenie systemu w cyklicznym konkursie BirdCLEF.
{% endtab %}

{% tab title="Wykorzystywane narzędzia" %}

* **Języki programowania:** Python 3.7+
* **Biblioteki ML:** *Pytorch* lub *TensorFlow*
* **Repozytorium kodu**: *GitHub.com* lub zakładowy *GitLab*&#x20;
* **Edycja pracy:** *LaTeX* (np. przez [Overleaf.com](https://www.overleaf.com/))&#x20;
* **Sprzęt:** W ramach zasobów Zakładu Sztucznej Inteligencji dostęp do systemu z GPU GeForce RTX 2080 Super (Ubuntu)
  {% endtab %}
  {% endtabs %}


# 2021L-ZZSN - projekty

Zaawansowane zagadnienia sieci neuronowych - projekty

## Prowadzone grupy

* grupa 101
* grupa 102
* grupa 103
* grupa 104

## Organizacja zajęć

Część projektowa zajęć z *Zaawansowanych zagadnień sieci neuronowych* polega na implementacji zaawansowanych modeli sieci neuronowych nawiązujących do tematów omawianych na wykładzie.

Projekty realizowane są w zespołach dwuosobowych. Celem projektu jest rozwiązanie problemu o charakterze użytkowym lub badawczym i jednoczesne zrozumienie danego zagadnienia przez zespół. Oznacza to, że przy realizacji można się posiłkować publicznymi implementacjami, ale nie zwalnia to zespołu z przygotowania się do dokładnego wytłumaczenia zasady działania prezentowanego rozwiązania.

Projekty powinny być realizowane w języku *Python 3.8+* z wykorzystaniem biblioteki *PyTorch,* ewentualnie *TensorFlow*. Sugerowanym podejściem do ustrukturyzowania kodu jest wykorzystanie biblioteki *PyTorch Lightning*. Szkielet takiego rozwiązania dostępny jest w repozytorium [2021L-ZZSN/template](https://github.com/2021L-ZZSN/template/).

Dodatkowe informacje udostępniane będą na bieżąco w zespole MS Teams przedmiotu.

### Zasady oceniania

Za część projektową można uzyskać łącznie 35 punktów:

* dokumentacja wstępna - 5 punktów,&#x20;
* implementacja modelu - 15 punktów,
* dokumentacja końcowa i prezentacja projektu - 15 punktów.

Dokumentacja wstępna powinna zawierać opis zadania, przewidywany sposób rozwiązania problemu i wyjaśnienie poczynionych założeń (typ modelu, wybrane zbiory danych, narzędzia, zakładana funkcjonalność itp.).

W ramach implementacji, poza zrealizowaną funkcjonalnością i zakresem eksperymentów, oceniana jest przede wszystkim jakość i czytelność wygenerowanego kodu. Kod powinien dać się uruchomić po postawieniu środowiska *conda* według pliku *environment.yml* z repozytorium (w wyjątkowych przypadkach obraz z *Dockerfile*). Mile widziane są adnotacje typowania statycznego i podstawowy zakres testów adekwatny do specyfiki testowania projektów machine learningowych, ale elementy te nie są wymagane do uzyskania maksymalnej liczby punktów, jeżeli nie ma żadnych innych zastrzeżeń.

W dokumentacji końcowej należy zawrzeć opis rozwiązania ze zwięzłym wyjaśnieniem kontekstu danego zagadnienia lub zasady działania modelu, wyniki eksperymentów i wnioski po realizacji projektu.

Dokumentację i kod źródłowy należy umieścić w repozytorium *git* dedykowanym dla zespołu (dokładne informacje na kanale MS Teams).

Niejasności można wyjaśniać poprzez MS Teams lub na konsultacjach (po [zapisaniu się](https://calendly.com/karolpiczak/)).

### Harmonogram

Wyszczególnione daty oznaczają termin na koniec dnia (23:59). Przez dostarczenie materiałów rozumiany jest *commit* w udostępnionym przeze mnie repozytorium dedykowanym dla projektu.

| Data                                                                                                    | Etap realizacji                                                                                                    |
| ------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------ |
| 19.03.2021 (piątek)                                                                                     | <p>Zgłoszenie składów zespołów wraz z preferencjami tematów<br>(proszę dołączyć loginy na GitHubie)</p>            |
| 22.03.2021 (poniedziałek)                                                                               | Przydział tematów do zespołów                                                                                      |
| **16.04.2021 (piątek)**                                                                                 | Dostarczenie dokumentacji wstępnej                                                                                 |
| <p><del><em><strong>2.06.2021 (środa)</strong></em></del></p><p><strong>8.06.2021 (wtorek)</strong></p> | Dostarczenie kodu źródłowego i dokumentacji końcowej                                                               |
| <p><del><em>7-11.06.2021</em></del></p><p>9-11.06.2021</p>                                              | Prezentacje i ocena projektów                                                                                      |
| <p><del><em>16.06.2021 (środa)</em></del></p><p>18.06.2021 (piątek)</p>                                 | <p>Ostateczny termin na oddanie projektu z karą -10 punktów</p><p>(po tym terminie projekty nie będą oceniane)</p> |

## Tematy projektów

| Lp. | Temat                                                                                                            |
| --- | ---------------------------------------------------------------------------------------------------------------- |
| 1   | **Zmiana pogody na zdjęciach za pomocą transferu stylu**                                                         |
| 2   | **Generowanie twarzy postaci z filmów animowanych za pomocą sieci GAN**                                          |
| 3   | **Detekcja maseczek ochronnych na zdjęciach z wykorzystaniem detektora YOLO**                                    |
| 4   | **Usuwanie tła za pomocą sieci typu U-Net**                                                                      |
| 5   | **Segmentacja zdjęć lotniczych za pomocą sieci typu U-Net**                                                      |
| 6   | **Wykorzystanie sieci impulsowej do klasyfikacji dźwięku**                                                       |
| 7   | **Przeciwstawne uczenie ciągłe klasyfikatorów dźwiękowych**                                                      |
| 8   | **Rezydualne uczenie ciągłe klasyfikatorów obrazowych**                                                          |
| 9   | **Wyszukiwanie efektywnych podsieci w klasyfikatorze danych dźwiękowych**                                        |
| 10  | **Wykorzystanie sieci kapsułkowych do klasyfikacji chmur punktów**                                               |
| 11  | **Predykcja liczby zachorowań na COVID-19 za pomocą grafowych sieci czasowo-przestrzennych**                     |
| 12  | **Analiza wydźwięku depesz giełdowych za pomocą modelu typu BERT**                                               |
| 13  | **Wykorzystanie architektury typu&#x20;*****Music Transformer*****&#x20;do generowania dzwonków telefonicznych** |
| 14  | **Wykorzystanie uczenia samonadzorowanego do poprawy klasyfikacji dźwięku**                                      |
| 15  | **Uczenie klasyfikatorów dźwiękowych niewielką liczbą przykładów z wykorzystaniem sieci prototypowych**          |
| ?   | *Możliwe tematy własne po konsultacji*                                                                           |

### **Omówienie tematów**

#### **1. Zmiana pogody na zdjęciach za pomocą transferu stylu**

{% hint style="info" %}
Celem projektu jest stworzenie narzędzia do konwersji zdjęcia z pochmurną pogodą na zdjęcie ze słoneczną pogodą.

**Schemat sugerowanego rozwiązania:**

* Pobranie obrazków z kamer internetowych (np. [*webcamgalore.com*](https://www.webcamgalore.com/)) z różnych momentów w czasie (*timelapse*).
* Wykorzystanie gotowego klasyfikatora pogody do oznaczenia zdjęcia jako pochmurne/słoneczne (ewentualnie adnotacja ręczna).
* Stworzenie sieci GAN do transferu stylu pochmurnie → słonecznie.
* Porównanie z uczeniem na zdjęciach, które nie pochodzą z tego samego ujęcia (np. [Two-Class Weather Classification](http://www.cse.cuhk.edu.hk/leojia/projects/weatherclassify/index.htm)).

{% endhint %}

**2. Generowanie twarzy postaci z filmów animowanych za pomocą sieci GAN**

{% hint style="info" %}
Celem projektu jest stworzenie narzędzia do generowania twarzy postaci kreskówkowych przy wykorzystaniu sieci GAN.

**Przykładowy zbiór danych:** [**iCartoonFace**](https://github.com/luxiangju-PersonAI/iCartoonFace)**,** ewentualnie [**Cartoon Set**](https://google.github.io/cartoonset/index.html)

Minimalny zakres to generowanie bezwarunkowe (dowolna twarz), ciekawsze rozwiązanie powinno uwzględniać możliwość sterowania charakterem generowanego obrazu.
{% endhint %}

**3. Detekcja maseczek ochronnych na zdjęciach z wykorzystaniem detektora YOLO**

{% hint style="info" %}
Celem projektu jest stworzenie detektora działającego w trybie real-time, który na zdjęciu z kamery oznaczy osoby z maseczkami ochronnymi i bez maseczek.

**Przykładowe zbiory danych:** [**Kaggle**](https://www.kaggle.com/datasets?search=face+mask)

W ramach podsumowania proszę przetestować działanie detektora na własnym filmie z kamery internetowej (ewentualnie zdjęciach z telefonu) albo na wybranym streamie dostępnym publicznie.
{% endhint %}

**4. Usuwanie tła za pomocą sieci typu U-Net**

{% hint style="info" %}
Celem projektu jest stworzenie narzędzia do usuwania/podmiany tła na zdjęciu twarzy.

**Przykładowy zbiór danych:** [**Matting Human Datasets**](https://www.kaggle.com/laurentmih/aisegmentcom-matting-human-datasets)

W ramach podsumowania proszę przetestować działanie narzędzia na własnych zdjęciach z telefonu lub filmie z kamery internetowej i porównać np. z rozmyciem dostępnym w MS Teams, Google Meet.

Do rozwiązania można też wykorzystać inne podejście niż wykorzystanie sieci U-Net.
{% endhint %}

**5. Segmentacja zdjęć lotniczych za pomocą sieci typu U-Net**

{% hint style="info" %}
Celem projektu jest stworzenie narzędzia do segmentacji zdjęć lotniczych wykorzystującego sieć typu U-Net.

**Przykładowy zbiór danych:** [**Aerial Semantic Segmentation Drone Dataset**](https://www.kaggle.com/bulentsiyah/semantic-drone-dataset)

W ramach podsumowania proszę przetestować działanie narzędzia na [mapach lotniczych Warszawy](http://mapa.um.warszawa.pl/mapaApp1/mapa?service=mapa).
{% endhint %}

**6. Wykorzystanie sieci impulsowej do klasyfikacji dźwięku**

{% hint style="info" %}
Celem projektu jest implementacja kilku wariantów prostych architektur sieci impulsowej i porównanie ich działania na zbiorze wizyjnym [*MNIST*](http://yann.lecun.com/exdb/mnist/) oraz zbiorze dźwiękowym [*ESC-50/ESC-10.*](https://github.com/karolpiczak/ESC-50)

**Sugerowany framework do implementacji:** [**BindsNET**](https://github.com/BindsNET/bindsnet)

Ze względu na eksperymentalny charakter zagadnienia osiągnięta dokładność klasyfikacji nie jest kryterium oceny jakości projektu, liczy się poprawność implementacji.
{% endhint %}

**7. Przeciwstawne uczenie ciągłe klasyfikatorów dźwiękowych**

{% hint style="info" %}
Celem projektu jest implementacja metody uczenia ciągłego określanej jako [*adversarial continual learning*](https://arxiv.org/pdf/2003.09553.pdf) i weryfikacja jej działania w kontekście klasyfikacji dźwięku (np. na [ESC-50](https://github.com/karolpiczak/ESC-50), [UrbanSound8K](https://urbansounddataset.weebly.com/urbansound8k.html) lub [FSD50K](https://zenodo.org/record/4060432#.YEo4u2hKiMo)).

W ramach podsumowania proszę porównać efektywność tego podejścia z wybraną metodą typu regularyzacyjnego i metodą typu *replay*.
{% endhint %}

**8. Rezydualne uczenie ciągłe klasyfikatorów obrazowych**

{% hint style="info" %}
Celem projektu jest implementacja metody uczenia ciągłego określanej jako [*residual continual learning*](https://arxiv.org/pdf/2002.06774.pdf) i weryfikacja jej działania w kontekście klasyfikacji obrazów (np. na CIFAR-10/CIFAR-100).

W ramach podsumowania proszę porównać efektywność tego podejścia z wybraną metodą typu regularyzacyjnego i metodą typu *replay*.
{% endhint %}

**9. Wyszukiwanie efektywnych podsieci w klasyfikatorze danych dźwiękowych**

{% hint style="info" %}
Celem projektu jest przebadanie działania metody [*early bird tickets*](https://github.com/RICE-EIC/Early-Bird-Tickets) do szybkiego wyszukiwania efektywnych podsieci w klasyfikatorach dźwiękowych (np. o architekturze zbliżonej do OpenL3).

W ramach podsumowania proszę zweryfikować dokładność działania modelu bazowego i podsieci typu *lottery ticket* na wybranych zbiorach z zakresu klasyfikacji dźwięku (np. [ESC-50](https://github.com/karolpiczak/ESC-50), [UrbanSound8K](https://urbansounddataset.weebly.com/urbansound8k.html), [FSD50K](https://zenodo.org/record/4060432#.YEo4u2hKiMo) lub [innych](http://dcase.community/)).
{% endhint %}

**10. Wykorzystanie sieci kapsułkowych do klasyfikacji chmur punktów**

{% hint style="info" %}
Celem projektu jest zastosowanie sieci kapsułkowych do klasyfikacji chmur punktów.

W ramach zadania wstępnego proszę sprawdzić działanie sieci kapsułkowej na zbiorze obrazowym (np. CIFAR-10).

W ramach podsumowania proszę porównać działanie sieci kapsułkowej z innym modelem (np. [PointNet++](http://stanford.edu/~rqi/pointnet2/)) w zadaniu klasyfikacji chmur punktów (np. [ShapeNetCore](https://shapenet.org/)).
{% endhint %}

**11. Predykcja liczby zachorowań na COVID-19 za pomocą grafowych sieci czasowo-przestrzennych**

{% hint style="info" %}
Celem projektu jest zastosowanie [czasowo-przestrzennej grafowej splotowej sieci neuronowej](https://arxiv.org/pdf/1709.04875.pdf) do predykcji liczby zachorowań na COVID-19 dla [danych ze Stanów Zjednoczonych](https://github.com/nytimes/covid-19-data) (podział na hrabstwa).

W ramach podsumowania proszę porównać działanie modelu z predykcjami prostych lokalnych modeli autoregresyjnych oraz zweryfikować poprawność implementacji na [zbiorze benchmarkowym zachorowań na ospę](https://pytorch-geometric-temporal.readthedocs.io/en/latest/modules/dataset.html#torch_geometric_temporal.data.dataset.chickenpox.ChickenpoxDatasetLoader).

Do implementacji zalecane jest wykorzystanie biblioteki [PyTorch Geometric Temporal](https://github.com/benedekrozemberczki/pytorch_geometric_temporal).

W przypadku tego projektu bardzo pożądanym elementem jest wizualizacja predykcji na mapie, np. za pomocą [Streamlit](https://docs.streamlit.io/en/stable/api.html#streamlit.map).
{% endhint %}

**12. Analiza wydźwięku depesz giełdowych za pomocą modelu typu BERT**

{% hint style="info" %}
Celem projektu jest wykorzystanie polskiego modelu typu BERT (np. [Herbert](https://huggingface.co/allegro/herbert-large-cased) albo [Polbert](https://huggingface.co/dkleczek/bert-base-polish-cased-v1)) do oceny wydźwięku (*negatywny/neutralny/pozytywny*) depesz na polskiej Giełdzie Papierów Wartościowych.

**Schemat sugerowanego rozwiązania:**

* Wykorzystanie modelu wstępnie trenowanego na korpusie języka polskiego do zadania analizy wydźwięku, np. na zbiorze [PolEmo2.0-IN](https://klejbenchmark.com/tasks/#polemo2.0-in). Porównanie działania modelu przy zmianie dziedziny ([PolEmo2.0-OUT](https://klejbenchmark.com/tasks/#polemo2.0-out)).
* Stworzenie bazy danych z [raportów systemu ESPI](http://infostrefa.com/infostrefa/pl/raporty/espi/biezace,0,0,0,1). Adnotacją wydźwięku generowaną syntetycznie może być następująca po komunikacie nadmiarowa zmiana [kursu akcji spółki](https://www.quandl.com/data/WSE-Warsaw-Stock-Exchange-GPW) w stosunku do zmiany szerokiego rynku.
* Weryfikacja działania modelu bez uczenia na danych z dziedziny finansowej i po wykorzystaniu raportów do dotrenowywania.
  {% endhint %}

**13. Wykorzystanie architektury typu&#x20;*****Music Transformer*****&#x20;do generowania dzwonków telefonicznych**

{% hint style="info" %}
Celem projektu jest stworzenie modelu o architekturze [*Music Transformer*](https://magenta.tensorflow.org/music-transformer), którego zadaniem jest generowanie krótkich fragmentów muzycznych o charakterze dzwonka telefonicznego.

**Schemat sugerowanego rozwiązania:**

* Przygotowanie zbioru [plików MIDI](https://github.com/albertmeronyo/awesome-midi-sources) o charakterze adekwatnym dla potencjalnego zastosowania.
* Wyuczenie modelu na przygotowanym zbiorze danych pod kątem bezwarunkowego generowania sekwencji MIDI i warunkowanego krótkim fragmentem początkowym.
* Przetworzenie wygenerowanych sekwencji do postaci dźwiękowej za pomocą syntezy offline (np. [NSynth](https://magenta.tensorflow.org/datasets/nsynth)), wybranego odtwarzacza MIDI w JavaScript albo wykorzystania wybranego [syntezatora VSTi](https://www.kvraudio.com/plugins/instruments/windows/macosx/linux/vst-plugins/free/most-popular) (np. przez [RenderMan](https://github.com/fedden/RenderMan)).
  {% endhint %}

**14. Wykorzystanie uczenia samonadzorowanego do poprawy klasyfikacji dźwięku**

{% hint style="info" %}
Celem projektu jest wyuczenie modelu rozumienia dźwięku w sposób samonadzorowany na zbiorze danych nieetykietowanych, np. wzorując się na podejściu [SimCLR](https://github.com/google-research/simclr) lub [MoCo](https://github.com/facebookresearch/moco). Tak wyuczony model należy następnie wykorzystać do klasyfikacji spektrogramów z mniejszego zbioru etykietowanego i porównać dokładność klasyfikacji z modelem uczonym w standardowy sposób (w pełni nadzorowany, tylko na zbiorze etykietowanym), ewentualnie przeanalizować odporność obydwu modeli na złośliwe modyfikacje typu *adversarial attacks*.

**Przykładowe zbiory danych:** [**ESC-US**](https://dataverse.harvard.edu/dataset.xhtml?persistentId=doi:10.7910/DVN/YDEPUT) i [**ESC-50**](https://github.com/karolpiczak/ESC-50)

Ze względu na większą złożoność obliczeniową technik samonadzorowanych wyniki podsumowania można oprzeć na modelu wyuczonym częściowo. Jeżeli sama implementacja i wytłumaczenie zespołu będzie bez zastrzeżeń, to nie wpływa to na końcową ocenę. W takim wypadku zalecałbym sprawdzenie implementacji na zbiorze CIFAR-10.
{% endhint %}

**15. Uczenie klasyfikatorów dźwiękowych niewielką liczbą przykładów z wykorzystaniem sieci prototypowych**

{% hint style="info" %}
Celem projektu jest stworzenie modelu [sieci protytypowej](https://arxiv.org/pdf/1703.05175.pdf) do uczenia klasyfikatorów dźwiękowych niewielką liczbą przykładów (*few-shot learning*).

**Schemat sugerowanego rozwiązania:**

* Stworzenie standardowego klasyfikatora dźwiękowego (np. na podstawie architektury [OpenL3](https://openl3.readthedocs.io/)) i wyuczenie go na zbiorze danych [FSD50K](https://annotator.freesound.org/fsd/release/FSD50K/).
* Sprawdzenie dokładności klasyfikacji przy standardowym uczeniu (bez ograniczeń na liczbę przykładów per klasa).
* Ocena tego samego modelu w uczeniu z ograniczoną liczbą przykładów (np. połowa klas dostępna normalnie, połowa tylko po $$K=5$$ przykładów uczących).
* Porównanie z działaniem modelu sieci prototypowej dla różnych wartości $$K$$ .
  {% endhint %}

## Zalecenia zbiorcze

Poza raportem końcowym dobrze byłoby, gdyby w ramach rozwiązania można zrozumieć i sprawdzić działanie modelu na przykładach, najlepiej w sposób interaktywny.

Sugerowanym narzędziem do tego typu prostych podsumowań jest [Streamlit](https://www.streamlit.io/), ewentualnie [Dash](http://dash.plotly.com/) lub inne rozwiązania tego typu.

### Zasoby obliczeniowe

Do realizacji projektów można wykorzystać darmowe zasoby obliczeniowe:

* [Google Colab](https://colab.research.google.com/)
* [Kaggle Code](https://www.kaggle.com/code)
* [Azure for Students](https://azure.microsoft.com/pl-pl/free/students/)
* [gradient](https://docs.paperspace.com/gradient/instances/instance-types/free-instances)

Jeżeli uda się pozyskać grant edukacyjny na przedmiot, to dostępne będą dodatkowo kupony do wykorzystania w *Google Cloud*.

W szczególnych przypadkach (np. uczenie samonadzorowane) możliwe jest też przydzielenie zasobów z puli uczelnianej.

{% hint style="warning" %}
W zależności od wymagań projektu i dostępnych mocy obliczeniowych uczenie modeli może zająć dłuższy czas (liczony w dniach). Proszę uwzględnić ten fakt przy rozplanowywaniu harmonogramu prac.
{% endhint %}


# 2020Z-ARKO - ćwiczenia

Architektura komputerów - ćwiczenia

## Prowadzone grupy

* grupa 2, poniedziałki 9:45-10:30
* grupa 6, wtorki 9:45-10:30

## Organizacja zajęć

W ramach ćwiczeń do zdobycia jest 20 punktów według kryteriów określonych przez koordynatora przedmiotu:

* 10 punktów - aktywność na zajęciach,
* 10 punktów - referat (zgłoszenia do p. Daszczuka).

Dopuszczalne są 2 nieusprawiedliwione nieobecności na ćwiczeniach.

Dodatkowe informacje i materiały do zajęć udostępniane są w zespole MS Teams przedmiotu.


# 2020L-AISDI - laboratoria

Algorytmy i struktury danych - zajęcia laboratoryjne

## Prowadzone grupy

* grupa 201, piątki parzyste, 10:15-12:00
* grupa 202, piątki nieparzyste, 10:15-12:00
* grupa 203, piątki nieparzyste, 10:15-12:00

Zajęcia są prowadzone wspólnie z p. [Waldemarem Grabskim](http://repo.bg.pw.edu.pl/index.php/pl/r#/info/author/WEITI-b0c820f2-f8e3-4353-9ca8-d5db6884d459/).

## Organizacja zajęć

Laboratoria polegają na rozwiązywaniu przedstawionych zadań w zespołach dwuosobowych. Łącznie za laboratoria do zdobycia jest 30 punktów, po 6 punktów za zadania realizowane na zajęciach 2-6. Do implementacji wykorzystywany jest język C++.

| Lp. | Tematyka zajęć                               | Ocenianie |
| --- | -------------------------------------------- | --------- |
| 1   | zajęcia wstępne, zapoznanie ze środowiskiem  | -         |
| 2   | sortowanie                                   | 6 pkt.    |
| 3   | drzewa                                       | 6 pkt.    |
| 4   | kopce                                        | 6 pkt.    |
| 5   | wyszukiwanie wzorca w tekście                | 6 pkt.    |
| 6   | grafy                                        | 6 pkt.    |
| 7   | termin rezerwowy (oddawanie zaległych zadań) | -         |

## Kryteria oceniania

| Punktacja | Wymagania względem rozwiązania                                                                                                             |
| --------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
| 6 pkt.    | poprawne i kompletne rozwiązanie zadania                                                                                                   |
| 5 pkt.    | rozwiązanie kompletne z niewielkimi uchybieniami (wydajność, przypadki skrajne)                                                            |
| 4 pkt.    | nieliczne błędy implementacyjne o większym znaczeniu, schemat rozwiązania poprawny i kompletny, rozwiązanie wykazuje zrozumienie materiału |
| 3 pkt.    | realizacja części zadania, liczne błędy w implementacji                                                                                    |
| 2 pkt.    | realizacja małej części zadania, liczne błędy w implementacji                                                                              |
| 1 pkt     | realizacja minimalnego zakresu funkcjonalności, bardzo liczne błędy w implementacji                                                        |
| 0 pkt.    | brak zgłoszonego rozwiązania                                                                                                               |

{% hint style="info" %}
Styl kodu oceniany jest w sposób binarny: **akceptowalny (0)**, **niewystarczający (-1)**.
{% endhint %}

{% hint style="info" %}
Poprawki wprowadzone do rozwiązania po zajęciach mogą podnieść punktację co najwyżej o 2 punkty.
{% endhint %}

{% hint style="danger" %}
Błędy dostępu do pamięci (odwoływanie się do nieważnego wskaźnika) traktowane są zawsze jako błędy o większym znaczeniu.
{% endhint %}


# 2019Z-AISDI - ćwiczenia

Algorytmy i struktury danych - ćwiczenia

## Prowadzone grupy

* grupa 102, wtorki nieparzyste, 12:15-14:00
* grupa 103, wtorki parzyste, 12:15-14:00
* grupa 105, wtorki parzyste, 14:15-16:00

## Organizacja zajęć

Zajęcia odbywają się co dwa tygodnie. W ramach ćwiczeń do zdobycia jest 20 punktów:

* 15 punktów - kolokwium,
* 5 punktów - aktywność, prezentacje, zadania domowe.

Punkty za aktywność przyznawane są za rozwiązywanie zadań w trakcie zajęć i aktywny udział w dyskusji (do zdobycia jeden punkt na spotkanie). Dodatkowo można zgłaszać rozwiązania zadań domowych. Maksymalnie można zgłosić trzy zadania domowe do oceny (każde za jeden punkt). Na dwóch ostatnich spotkaniach możliwe będzie również zaprezentowanie wybranego algorytmu przez zespoły dwuosobowe (dwa punkty do zdobycia dla każdego z prezentujących).

| Lp. | Tematyka zajęć                                                                    |
| --- | --------------------------------------------------------------------------------- |
| 1   | lista, binarne drzewo poszukiwań (*BST*)                                          |
| 2   | algorytmy sortowania                                                              |
| 3   | drzewa AVL, drzewa splay                                                          |
| 4   | kopce                                                                             |
| 5   | **kolokwium (planowe terminy: gr. 102 - 10 grudnia, gr. 103 i 105 - 17 grudnia)** |
| 6   | wyszukiwanie wzorca w tekście - prezentacje                                       |
| 7   | algorytmy grafowe - prezentacje                                                   |

Dokładny zakres materiału obowiązującego na kolokwium zamieszczony jest na [osobnej podstronie](/dydaktyka/2019z-aisdi-cwiczenia/kolokwium).&#x20;

## Zasady zgłaszania zadań domowych

Rozwiązania zadań należy zgłaszać przez udostępnienie repozytorium na wydziałowym serwerze *GitLab* i przydzielenie *merge request* [prowadzącemu](https://gitlab-stud.elka.pw.edu.pl/karolpiczak), analogicznie do [zasad na laboratoriach](https://files.pw.karolpiczak.com/Instrukcja-GitLab.pdf). *Merge request* proszę zatytułować `AISDI-HW X: Nazwisko`, gdzie `X` jest kolejnym numerem zadania.

**Termin na zgłaszanie zadań:** do kolokwium

* [**Zadanie #1**](/dydaktyka/2019z-aisdi-cwiczenia/zadanie-domowe-1)
* [**Zadanie #2**](/dydaktyka/2019z-aisdi-cwiczenia/zadanie-domowe-2)
* [**Zadanie #3**](/dydaktyka/2019z-aisdi-cwiczenia/zadanie-domowe-3)
* [**Zadanie #4**](https://pw.karolpiczak.com/dydaktyka/2019z-aisdi-cwiczenia/zadanie-domowe-4)

{% hint style="danger" %}
Do oceny można zgłosić maksymalnie trzy wybrane zadania domowe.
{% endhint %}


# Kolokwium

Zakres materiału obowiązującego na kolokwium

{% hint style="warning" %}

* [**Arkusz odpowiedzi dla wersji A kolokwium**](https://files.pw.karolpiczak.com/2019Z-AISDI-Kolokwium-A-odp.pdf)
* [**Arkusz odpowiedzi dla wersji B kolokwium**](https://files.pw.karolpiczak.com/2019Z-AISDI-Kolokwium-B-odp.pdf)
* [**Arkusz odpowiedzi dla wersji C kolokwium**](https://files.pw.karolpiczak.com/2019Z-AISDI-Kolokwium-C-odp.pdf)
* [**Arkusz odpowiedzi dla wersji D kolokwium**](https://files.pw.karolpiczak.com/2019Z-AISDI-Kolokwium-D-odp.pdf)<br>
* [**Arkusz oceniania dla wersji A/B kolokwium**](https://files.pw.karolpiczak.com/2019Z-AISDI-Kolokwium-Ocenianie-AB.pdf)
* [**Arkusz oceniania dla wersji C/D kolokwium**](https://files.pw.karolpiczak.com/2019Z-AISDI-Kolokwium-Ocenianie-CD.pdf)
  {% endhint %}

## Ćwiczenia 1

{% hint style="info" %}
Przykłady implementacji struktur listowych dostępne są w [repozytorium z materiałami do przedmiotu](https://github.com/karolpiczak-pw/2019Z-AISDI/tree/master/examples/01-list-bst).
{% endhint %}

### 1.1 **Tablica, std::array, std::vector**

{% tabs %}
{% tab title="1.1 Zakres materiału" %}

* podstawowe **operacje na tablicy/wektorze** i ich złożoność:
  * dostęp,
  * wstawianie elementu (na końcu/w środku),
  * usuwanie elementu (z końca/ze środka),
  * wyszukiwanie elementu o określonej wartości
* różnica między `std::vector::size()` a `std::vector::capacity()`,
* wykorzystanie **iteratorów**
  {% endtab %}
  {% endtabs %}

### 1.2 **Lista jedno- i dwukierunkowa**

{% tabs %}
{% tab title="1.2 Zakres materiału" %}

* podstawowe **operacje na liście** i ich złożoność:
  * dostęp,
  * wstawianie elementu,
  * usuwanie elementu,
  * wyszukiwanie elementu o określonej wartości
* **wyszukiwanie ze strażnikiem**
  {% endtab %}

{% tab title="1.2 Materiały pomocnicze" %}
{% hint style="info" %}
**Ogólne:**

* [Linked list data structure (Geeks for Geeks)](https://www.geeksforgeeks.org/data-structures/linked-list/)

**Wykorzystanie strażnika:**

* [Sentinel node (Wikipedia)](https://en.wikipedia.org/wiki/Sentinel_node)
* [Using sentinel nodes (Stack Overflow)](https://stackoverflow.com/a/5384593/308759)

**Wizualizacje:**

* [List (VisuAlgo)](https://visualgo.net/en/list)
  {% endhint %}
  {% endtab %}
  {% endtabs %}

{% tabs %}
{% tab title="1.2 Zadania:" %}

{% endtab %}

{% tab title="1.2.1" %}
Dany jest następujący szkielet klasy listy jednokierunkowej:

```cpp
struct Node {
    Node* next;
    int value;
};

class LinkedList {
  public:
    int length;
    Node* head;

    LinkedList();

    void erase_after(int pos);  // usuwa elem. za pozycją pos
    void insert_after(int pos, int value);  // wstawia elem. za pozycją pos
    void pop_front();  // usuwa pierwszy element
    void push_front(int value);  // wstawia element na początek listy
};
```

Zaimplementuj brakujące metody.
{% endtab %}

{% tab title="1.2.2" %}
Zaimplementuj metodę, która dla listy jednokierunkowej zwróci trzeci element od końca. Załóż, że długość listy nie jest znana.
{% endtab %}

{% tab title="1.2.3" %}
Zaimplementuj metodę, która zwróci środkowy element listy jednokierunkowej. Załóż, że długość listy nie jest znana.
{% endtab %}

{% tab title="1.2.4" %}
Zaproponuj sposób odwracania listy jednokierunkowej w jednym przejściu bez tworzenia kopii wszystkich elementów.
{% endtab %}

{% tab title="1.2.5" %}
Zaproponuj sposób usuwania węzła mając tylko odwołanie do niego. Załóż, że nie jest to ostatni węzeł listy.
{% endtab %}

{% tab title="1.2.6" %}
Zaimplementuj uproszczony iterator (tylko operacje `->` i `++` ) po elementach listy. Jak wyglądałby taki iterator, gdyby miał zwracać najpierw elementy na rosnących pozycjach nieparzystych listy, a następnie na parzystych?
{% endtab %}
{% endtabs %}

### 1.3 **Kolejka (FIFO), stos (LIFO)**

{% tabs %}
{% tab title="1.3 Zakres materiału" %}

* pojęcie **abstrakcyjnego typu danych** (*abstract data type, ADT*),
* **kolejka** i **stos** jako przykłady ADT,
* implementacja funkcjonalności kolejki i stosu na bazie listy dwukierunkowej
  {% endtab %}

{% tab title="1.3 Materiały pomocnicze" %}
{% hint style="info" %}
**ADT:**

* [Queue ADT (Wikipedia)](https://en.wikipedia.org/wiki/Queue_%28abstract_data_type%29)
* [Stack ADT (Wikipedia)](https://en.wikipedia.org/wiki/Stack_%28abstract_data_type%29)

**Wizualizacje:**

* [Queue (VisuAlgo)](https://visualgo.net/en/list?slide=5)
* [Stack (VisuAlgo)](https://visualgo.net/en/list?slide=4)
  {% endhint %}
  {% endtab %}
  {% endtabs %}

### 1.4 Binarne drzewo poszukiwań (BST)

{% tabs %}
{% tab title="1.4 Zakres materiału" %}

* **drzewo binarne**, definicja, podstawowe własności,
* **binarne drzewo poszukiwań** (*binary search tree*, *BST*):
  * podstawowe operacje i ich złożoność:
    * dostęp,
    * wyszukiwanie elementu,
    * wstawianie elementu,
    * usuwanie elementu
  * przechodzenie po węzłach drzewa:
    * in-order,
    * pre-order,
    * post-order
  * implementacja iteratora dla drzewa
    {% endtab %}

{% tab title="1.4 Materiały pomocnicze" %}
{% hint style="info" %}
**Ogólne:**

* [Binary tree (Wikipedia)](https://en.wikipedia.org/wiki/Binary_tree)
* [Binarne drzewo poszukiwań (Wikipedia)](https://pl.wikipedia.org/wiki/Binarne_drzewo_poszukiwa%C5%84)
* [Binary search tree (Programiz)](https://www.programiz.com/dsa/breadth-first-search-tree)

**Przechodzenie drzewa:**

* [Tree traversal (Wikipedia)](https://en.wikipedia.org/wiki/Tree_traversal)
* [Binary search tree iterator (LeetCode)](https://leetcode.com/problems/binary-search-tree-iterator/solution/)

**Wizualizacje:**

* [BST (VisuAlgo)](https://visualgo.net/en/bst)
  {% endhint %}
  {% endtab %}
  {% endtabs %}

{% tabs %}
{% tab title="1.4 Zadania" %}

{% endtab %}

{% tab title="1.4.1" %}
Narysuj binarne drzewo poszukiwań utworzone przez wstawienie w kolejności elementów:

`31, 72, 23, 44, 85, 106, 17, 28, 9, 30, 41`
{% endtab %}

{% tab title="1.4.2" %}
Zaimplementuj metody wstawiania i wyszukiwania węzła w drzewie BST.
{% endtab %}

{% tab title="1.4.3" %}
Zaimplementuj rekursywne przechodzenie po węzłach drzewa w kolejności "in-order".
{% endtab %}

{% tab title="1.4.4" %}
Zaimplementuj uproszczony iterator (tylko operacje `->` i `++` ), który będzie przechodził węzły drzewa w kolejności "in-order".
{% endtab %}

{% tab title="1.4.5" %}
Zaimplementuj w klasie drzewa BST funkcjonalność usuwania węzła o zadanej wartości.
{% endtab %}
{% endtabs %}

## Ćwiczenia 2

{% hint style="info" %}
Przykładowe implementacje omawianych algorytmów sortowania dostępne są w [repozytorium z materiałami do przedmiotu](https://github.com/karolpiczak-pw/2019Z-AISDI/tree/master/examples/02-sorting).
{% endhint %}

### 2.1 Algorytmy sortowania

{% tabs %}
{% tab title="2.1 Zakres materiału" %}
**Algorytmy:**

* sortowanie przez wybieranie (***selection sort***),
* sortowanie przez wstawianie (***insertion sort***),
* sortowanie bąbelkowe (***bubble sort***),
* sortowanie szybkie (***quicksort***),
* sortowanie przez scalanie (***merge*** ***sort***),
* sortowanie przez kopcowanie (***heapsort***),
* sortowanie kubełkowe (***bucket sort***)

**Dla przedstawionych algorytmów:**

* implementacja,
* złożoność czasowa (najlepsza, średnia, najgorsza),
* złożoność pamięciowa,
* stabilność
  {% endtab %}

{% tab title="2.1 Materiały pomocnicze" %}
{% hint style="info" %}
**Ogólne:**

* [Sorting algorithm (Wikipedia)](https://en.wikipedia.org/wiki/Sorting_algorithm)
* [Sorting stability (Wikipedia)](https://en.wikipedia.org/wiki/File:Sorting_stability_playing_cards.svg)
* [Sorting algorithms (O'Reilly)](https://www.oreilly.com/library/view/algorithms-in-a/9781491912973/ch04.html)

**Algorytmy:**

* [Selection sort (w3resource)](https://www.w3resource.com/python-exercises/data-structures-and-algorithms/python-search-and-sorting-exercise-5.php)
* [Bubble sort (w3resource)](https://www.w3resource.com/javascript-exercises/javascript-function-exercise-24.php)
* [Insertion sort (w3resource)](https://www.w3resource.com/python-exercises/data-structures-and-algorithms/python-search-and-sorting-exercise-6.php)
* [Quicksort (w3resource)](https://www.w3resource.com/csharp-exercises/searching-and-sorting-algorithm/searching-and-sorting-algorithm-exercise-9.php)
* [Merge sort (101computing)](https://www.101computing.net/merge-sort-algorithm/)
* [Heapsort (HackerEarth)](https://www.hackerearth.com/practice/algorithms/sorting/heap-sort/tutorial/)
* [Bucket sort (Programiz)](https://www.programiz.com/dsa/bucket-sort)

**Wizualizacje:**

* [Sorting (sorting.at)](http://sorting.at/)
* [Sorting (VisuAlgo)](https://visualgo.net/en/sorting)
* [Comparison sorting (USF)](https://www.cs.usfca.edu/~galles/visualization/ComparisonSort.html)
* [Sorting algorithms (toptal)](https://www.toptal.com/developers/sorting-algorithms)
* [Bucket sort (USF)](https://www.cs.usfca.edu/~galles/visualization/BucketSort.html)
  {% endhint %}
  {% endtab %}
  {% endtabs %}

## Ćwiczenia 3

### 3.1 Drzewa

{% tabs %}
{% tab title="3.1 Zakres materiału" %}

* drzewa BST zrównoważone i niezrównoważone,
* **rotacje drzew,**
* **drzewa splay**:
  * implementacja i złożoność obliczeniowa:
    * operacja *splay*,
    * wyszukiwanie elementu,
    * wstawianie elementu,
    * usuwanie elementu,
  * zastosowania drzewa splay, zalety i wady
* **drzewa AVL**:
  * wysokość, współczynnik wyważenia,
  * operacje równoważenia drzewa AVL,
  * implementacja i złożoność obliczeniowa:
    * wyszukiwanie elementu,
    * wstawianie elementu,
    * usuwanie elementu
      {% endtab %}

{% tab title="3.1 Materiały pomocnicze" %}
{% hint style="info" %}
**Zrównoważenie drzewa BST:**

* [Wyważanie drzewa (Wikipedia)](https://pl.wikipedia.org/wiki/Binarne_drzewo_poszukiwa%C5%84#Wywa%C5%BCanie_drzewa)

**Rotacje:**

* [Tree rotation (Wikipedia)](https://en.wikipedia.org/wiki/Tree_rotation)

**Drzewa splay:**

* [Drzewo splay (Wikipedia)](https://pl.wikipedia.org/wiki/Drzewo_splay)
* [Splay tree rotation (Stack Exchange)](https://cs.stackexchange.com/q/1229/8837)
* [Self-Adjusting Binary Search Trees paper (CMU)](https://www.cs.cmu.edu/~sleator/papers/self-adjusting.pdf)
* [Splay trees lecture notes (Berkeley)](https://people.eecs.berkeley.edu/~jrs/61b/lec/36)

**Drzewa AVL:**

* [AVL tree (Wikipedia)](https://en.wikipedia.org/wiki/AVL_tree)
* [AVL trees (CodesDope)](https://www.codesdope.com/course/data-structures-avl-trees/)

**Wizualizacje:**

* [Splay tree (USF)](https://www.cs.usfca.edu/~galles/visualization/SplayTree.html)
* [AVL (VisuAlgo)](https://visualgo.net/en/bst?slide=14)
  {% endhint %}
  {% endtab %}
  {% endtabs %}

{% tabs %}
{% tab title="3.1 Zadania:" %}

{% endtab %}

{% tab title="3.1.1" %}
Stwórz dwa drzewa BST przez wstawianie w kolejności następujących wartości:

`A: 40, 20, 60, 10, 30, 50, 70`

`B: 10, 20, 30, 40, 50, 60, 70`

Porównaj złożoność podstawowych operacji dla obydwu drzew.

Następnie dla drzewa niezrównoważonego **B** wykonaj kolejno operacje rotacji:

* `L(40)`
* `L(30)`
* `L(20)`
* `L(10)`
* `L(20)`

{% hint style="info" %}
Zapis `L(R)` oznacza rotację lewą, dla której korzeniem jest węzeł o wartości `R`.
{% endhint %}
{% endtab %}

{% tab title="3.1.2" %}
Dane jest drzewo splay o takiej samej strukturze jak drzewo A z zadania 1.

Wykonaj w kolejności następujące operacje:

* znajdź element o wartości `30`,
* znajdź element o wartości `50`,
* wstaw element o wartości `25`,
* wstaw element o wartości `22`,
* usuń element o wartości `50`,
* usuń element o wartości `25`.
  {% endtab %}

{% tab title="3.1.3" %}
Stwórz drzewo AVL przez wstawianie kolejno wartości:

`10, 20, 30, 40, 50, 60, 70`

Na stworzonym drzewie przeprowadź operacje:

* wstaw element o wartości `55`,
* wstaw element o wartości `52`,
* usuń element o wartości `52`,
* usuń element o wartości `70`.
  {% endtab %}
  {% endtabs %}

## Ćwiczenia 4

{% hint style="info" %}
Przykładowe implementacje omawianych kopców dostępne są w [repozytorium z materiałami do przedmiotu](https://github.com/karolpiczak-pw/2019Z-AISDI/tree/master/examples/04-heaps).
{% endhint %}

### 4.1 Kopce

{% tabs %}
{% tab title="4.1 Zakres materiału" %}

* kolejka priorytetowa (***priority queue***, *ADT*),
* **kopiec binarny**:
  * własność kopca ***min-heap***, ***max-heap***,
  * reprezentacja tablicowa kopca (*implicit data structure*),
  * implementacja i złożoność obliczeniowa operacji:
    * dostęp do najmniejszego elementu,
    * wstawianie nowego elementu,
    * usuwanie najmniejszego elementu,
    * budowa kopca:
      * metoda Williamsa (sukcesywne wstawianie elementów),
      * metoda Floyda (przywracanie własności kopca dla tablicy)
* **kopce** ***d*****-arne**:
  * *3*-heap (*ternary heap*) i *4*-heap (*quaternary heap*),
  * zalety i wady zastosowania arności wyższego rzędu,
* **kopiec dwumianowy**:
  * kopiec dwumianowy jako przykład kopca złączalnego (***mergeable heap***),
  * własności kopca dwumianowego,
  * implementacja i złożoność obliczeniowa operacji:
    * dostęp do najmniejszego elementu,
    * wstawianie nowego elementu,
    * usuwanie najmniejszego elementu,
    * scalanie kopców
* **kopiec Fibonacciego**:
  * implementacja i złożoność obliczeniowa operacji:
    * dostęp do najmniejszego elementu,
    * wstawianie nowego elementu,
    * usuwanie najmniejszego elementu,
    * scalanie kopców
      {% endtab %}

{% tab title="4.1 Materiały pomocnicze" %}
{% hint style="info" %}
**Ogólne:**

* [Priority queue ADT (Wikipedia)](https://en.wikipedia.org/wiki/Priority_queue)
* [Heap (Wikipedia)](https://en.wikipedia.org/wiki/Heap_%28data_structure%29)
* [Implicit data structure (Wikipedia)](https://en.wikipedia.org/wiki/Implicit_data_structure)

**Kopiec binarny:**

* [Binary heap (Wikipedia)](https://en.wikipedia.org/wiki/Binary_heap)
* [Building a heap in O(n) time (Stack Overflow)](https://stackoverflow.com/questions/9755721/how-can-building-a-heap-be-on-time-complexity)
* [Binary heap (Brilliant)](https://brilliant.org/wiki/binary-heap/)

**Kopce** ***d*****-arne:**

* [D-ary heap (Wikipedia)](https://en.wikipedia.org/wiki/D-ary_heap)
* [Binary heap vs d-ary heap (Stack Overflow)](https://stackoverflow.com/questions/29126428/binary-heaps-vs-d-ary-heaps)
* [Ternary and quaternary heaps (Stack Overflow)](https://stackoverflow.com/questions/48843677/why-dont-we-use-ternary-or-quaternary-heaps)

**Kopiec dwumianowy:**

* [Binomial heap (Wikipedia)](https://en.wikipedia.org/wiki/Binomial_heap)
* [Binomial heap (Brilliant)](https://brilliant.org/wiki/binomial-heap/)
* [Binomial heap (Growing with the Web)](https://www.growingwiththeweb.com/data-structures/binomial-heap/overview/)

**Kopiec Fibonacciego:**

* [Fibonacci heap (Wikipedia)](https://en.wikipedia.org/wiki/Fibonacci_heap)
* [Fibonacci heap (Brilliant)](https://brilliant.org/wiki/fibonacci-heap/)
* [Fibonacci heap lecture notes (Princeton)](https://www.cs.princeton.edu/~wayne/teaching/fibonacci-heap.pdf)

**Wizualizacje:**

* [Heap (VisuAlgo)](https://visualgo.net/en/heap)
* [Heap (USF)](https://www.cs.usfca.edu/~galles/visualization/Heap.html)
* [Binomial heap (USF)](https://www.cs.usfca.edu/~galles/visualization/BinomialQueue.html)
* [Fibonacci heap (USF)](https://www.cs.usfca.edu/~galles/visualization/FibonacciHeap.html)
  {% endhint %}
  {% endtab %}
  {% endtabs %}

{% tabs %}
{% tab title="4.1 Zadania:" %}

{% endtab %}

{% tab title="4.1.1" %}
Zapisz w reprezentacji tablicowej drzewo binarne następującej postaci:

![](/files/-LuZsfIqxE_WvFBFo9bA)
{% endtab %}

{% tab title="4.1.2" %}
Dla zapisu tablicowego:

`[95, 80, 85, 40, 70, 90, 50, 30, 10, 20]`

narysuj zupełne drzewo binarne. Czy drzewo to przedstawia kopiec typu *max-heap*?
{% endtab %}

{% tab title="4.1.3" %}
Do pustego **kopca binarnego** ***max-heap*** wstaw w kolejności elementy o wartościach klucza:

`43, 24, 11, 47, 13, 67, 59, 95, 29, 17, 54, 40`

Następnie trzykrotnie wykonaj operację usunięcia największego elementu z kopca.

Zilustruj stan kopca po każdym kroku.
{% endtab %}

{% tab title="4.1.4" %}
Z podanej tablicy stwórz **kopiec binarny typu** ***max-heap*** metodą Floyda (przywracanie własności kopca kolejnym poddrzewom):

`[2, 7, 26, 25, 19, 17, 1, 90, 3, 36]`

Zlicz ilość wykonanych operacji, porównaj z metodą tworzenia kopca przez wstawianie.
{% endtab %}

{% tab title="4.1.5" %}
Do pustego **kopca 3-arnego (*****ternary heap*****) typu** ***max-heap*** wstaw w kolejności elementy o wartościach klucza:

`43, 24, 11, 47, 13, 67, 59, 95, 29, 17, 54, 40`

Następnie trzykrotnie wykonaj operację usunięcia największego elementu z kopca.

Zilustruj stan kopca po każdym kroku.
{% endtab %}

{% tab title="4.1.6" %}
Do pustego **kopca dwumianowego typu** ***min-heap*** wstaw w kolejności elementy o wartościach klucza:

`43, 24, 11, 47, 13, 67, 59, 95, 29, 17, 54, 40`

Następnie trzykrotnie wykonaj operację usunięcia najmniejszego elementu z kopca.

Zilustruj stan kopca po każdym kroku.
{% endtab %}

{% tab title="4.1.7" %}
Do pustego **kopca Fibonacciego typu** ***min-heap*** wstaw w kolejności elementy o wartościach klucza:

`43, 24, 11, 47, 13, 67, 59, 95, 29, 17, 54, 40`

Następnie trzykrotnie wykonaj operację usunięcia najmniejszego elementu z kopca.

Zilustruj stan kopca po każdym kroku.

Porównaj stany przejściowe kopca stworzonego na bazie poniższego ciągu operacji:

* `push(43)`,
* `push(24)`,
* `push(11)`,
* `push(47)`,
* `pop()`,
* `push(13)`,
* `push(67)`,
* `pop()`,
* `push(59)`,
* `push(95)`,
* `pop()`,
* `push(29)`,
* `push(17)`,
* `pop()`,
* `push(54)`,
* `pop()`,
* `push(40)`.
  {% endtab %}
  {% endtabs %}


# Prezentacje

Tematy prezentacji na zajęciach styczniowych

Prezentacje w zespołach dwuosobowych.

**Czas prezentacji:** 10 minut + 3 minuty na pytania.

Slajdy do prezentacji (maksymalnie 5 slajdów) proszę przesłać mailowo przed zajęciami.

## **Wyszukiwanie w tekście**

* 7 stycznia 2020 r. - grupy 103, 105
* 14 stycznia 2020 r. - grupa 102

| Lp. | Temat prezentacji                                                                                            | Grupa 102 | Grupa 103 | Grupa 105 |
| --- | ------------------------------------------------------------------------------------------------------------ | --------- | --------- | --------- |
| 1   | [algorytm Knutha-Morrisa-Pratta](https://en.wikipedia.org/wiki/Knuth%E2%80%93Morris%E2%80%93Pratt_algorithm) | -         | -         | *wolny*   |
| 2   | [algorytm Boyera-Moore'a](https://en.wikipedia.org/wiki/Boyer%E2%80%93Moore_string-search_algorithm)         | -         | -         | -         |
| 3   | [algorytm Rabina-Karpa](https://en.wikipedia.org/wiki/Rabin%E2%80%93Karp_algorithm)                          | -         | -         | *wolny*   |
| 4   | [algorytm Aho-Corasick](https://en.wikipedia.org/wiki/Aho%E2%80%93Corasick_algorithm)                        | -         | *wolny*   | *wolny*   |
| 5   | [algorytm *bitap* (*shift-and*)](https://en.wikipedia.org/wiki/Bitap_algorithm)                              | -         | *wolny*   | *wolny*   |

## Algorytmy grafowe

* 21 stycznia 2020 r. - grupy 103, 105
* 28 stycznia 2020 r. - grupa 102

| Lp. | Temat prezentacji                                                                       | Grupa 102 | Grupa 103 | Grupa 105 |
| --- | --------------------------------------------------------------------------------------- | --------- | --------- | --------- |
| 1   | [algorytm Prima](https://en.wikipedia.org/wiki/Prim%27s_algorithm)                      | -         | -         | -         |
| 2   | [algorytm Kruskala](https://en.wikipedia.org/wiki/Kruskal%27s_algorithm)                | -         | *wolny*   | -         |
| 3   | [algorytm Bellmana-Forda](https://en.wikipedia.org/wiki/Bellman%E2%80%93Ford_algorithm) | -         | *wolny*   | -         |
| 4   | [algorytm Dijkstry](https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm)               | -         | -         | -         |
| 5   | [algorytm A\*](https://en.wikipedia.org/wiki/A*_search_algorithm)                       | -         | -         | -         |


# Zadanie domowe #1

{% hint style="danger" %}
Do oceny można zgłosić maksymalnie trzy wybrane zadania domowe.
{% endhint %}

**Nazwa repozytorium z rozwiązaniem:** `AISDI-HW 1: Nazwisko`

### Treść zadania

Zaimplementuj operację usuwania węzła z binarnego drzewa poszukiwań.

{% hint style="info" %}
Dopuszczalne są implementacje w językach C++, Python, Java.
{% endhint %}

{% hint style="warning" %}
Rozwiązanie powinno również zawierać przynajmniej podstawowy zakres testów weryfikujących poprawność implementacji.
{% endhint %}


# Zadanie domowe #2

{% hint style="danger" %}
Do oceny można zgłosić maksymalnie trzy wybrane zadania domowe.
{% endhint %}

**Nazwa repozytorium z rozwiązaniem:** `AISDI-HW 2: Nazwisko`

### Treść zadania

Zaimplementuj program, który:

* wygeneruje losową permutację standardowej talii kart (52 karty),
* posortuje uzyskany ciąg kart w porządku rosnącym (od dwójki do asa) w sposób

  stabilny (wejściowa kolejność kolorów zachowana) wykorzystując algorytm

  *selection sort* i strukturę listy.

{% hint style="info" %}
Sugerowane oznaczenia kolorów: **S**:spades: **H**:hearts: **D**:diamonds: **C**:clubs:&#x20;
{% endhint %}

{% hint style="info" %}
Dopuszczalne są implementacje w językach C++, Python, Java.
{% endhint %}

{% hint style="warning" %}
Rozwiązanie powinno również zawierać przynajmniej podstawowy zakres testów weryfikujących poprawność implementacji.
{% endhint %}


# Zadanie domowe #3

{% hint style="danger" %}
Do oceny można zgłosić maksymalnie trzy wybrane zadania domowe.
{% endhint %}

{% hint style="info" %}
Materiały pomocnicze do zadania znajdują się w [repozytorium na GitHub](https://github.com/karolpiczak-pw/2019Z-AISDI/tree/master/homework/03-trees).
{% endhint %}

**Nazwa repozytorium z rozwiązaniem:** `AISDI-HW 3: Nazwisko`

### Treść zadania

Rozpatrujemy standardowe [binarne drzewo poszukiwań](https://en.wikipedia.org/wiki/Binary_search_tree), [drzewo typu splay](https://en.wikipedia.org/wiki/Splay_tree) i [drzewo AVL](https://en.wikipedia.org/wiki/AVL_tree). Proszę naszkicować kolejne stany poszczególnych drzew po każdej z wykonywanych operacji:

* wstaw kolejno wartości `51, 22, 43, 84, 35, 86, 57, 98`,
* następnie znajdź wartość `57`,
* następnie usuń kolejno wartości `57, 51`.

Schemat wywołania tych operacji wyglądałby następująco:

{% code title="trees.cpp" %}

```cpp
#include <vector>


template<typename Key>
struct Node {
    Key key;
    // ...
};


template<typename Key>
class Tree {
    public:
        // ...
        virtual void erase(const Key& key) { /* ... */ }
        virtual Node<Key>* insert(const Key& key) { /* ... */ }
        virtual Node<Key>* find(const Key& key) const { /* ... */ }
};


template<typename Key>
class BinarySearchTree : public Tree<Key> {
    // ...
};


template<typename Key>
class SplayTree : public Tree<Key> {        
    // ...
};


template<typename Key>
class AVLTree : public Tree<Key> {        
    // ...
};


// ...
    auto bst = BinarySearchTree<int>();
    auto splay = SplayTree<int>();
    auto avl = AVLTree<int>();

    std::vector<Tree<int>*> trees{};
    trees.push_back(&bst);
    trees.push_back(&splay);
    trees.push_back(&avl);

    // Operacje wykonujemy dla każdego typu drzewa
    for (const auto& tree : trees) {
        tree->insert(51); // ...-00.pdf
        tree->insert(22); // ...-01.pdf
        tree->insert(43); // ...-02.pdf
        tree->insert(84); // ...-03.pdf
        tree->insert(35); // ...-04.pdf
        tree->insert(86); // ...-05.pdf
        tree->insert(57); // ...-06.pdf
        tree->insert(98); // ...-07.pdf
        
        tree->find(57);   // ...-08.pdf
        
        tree->erase(57);  // ...-09.pdf
        tree->erase(51);  // ...-10.pdf
    }
// ...
```

{% endcode %}

Do realizacji szkiców można wykorzystać na przykład pakiet [***Graphviz***](https://www.graphviz.org/) lub [***LaTeX***](https://www.latex-project.org/).

{% hint style="warning" %}
W ramach niniejszego zadania domowego **nie jest wymagana implementacja poszczególnych drzew**. Operacje można "policzyć" na kartce i na tej podstawie bezpośrednio przygotować szkice.
{% endhint %}

### Przykład zapisu drzewa w języku DOT (Graphviz)

{% tabs %}
{% tab title="tree\_basic.dot" %}

```bash
# Basic tree in DOT format
# 
# Generate PNG file with:
# > dot -Tpng -o tree_basic.png tree_basic.dot

strict digraph dot {

	40 -> 20
	40 -> 60

	20 -> 10
	20 -> 30

	60 -> 50
	60 -> 70

}

```

{% endtab %}

{% tab title="tree.dot" %}

```bash
# Tree in DOT format, extended with GNU M4 macros and some additional styling
#
# Styles:
# - null pointers [NULL]
# - root node [YELLOW]
# - invisible padding nodes & edges for more symmetrical binary
#   tree [INVISIBLE_N/INVISIBLE_E] 
#
# Generate PNG file with:
# > m4 tree.dot | dot -Tpng -o tree.png 

define(YELLOW, `color = "#ffc49c", fillcolor = "#ffe1cc:#ffe7d7"')
define(NULL, `label = "", width = .1, height = .1, color = "#b3b3b3", fillcolor = "#d7d7d7:#e4e4e4"')
define(INVISIBLE_E, `style = invisible, arrowsize = 0, weight = 10')
define(INVISIBLE_N, `style = invisible, label = ""')


strict digraph dot {

    graph [
        layout = dot,
        dpi = 300,
        nodesep = 0.2,
        ranksep = 0.5,
        splines = line,
        ordering = out,
    ]

    edge [
        color = "#89cadd",
        penwidth = 2,
        arrowsize = 0.7,
    ]

    node [
        style = filled,
        color = "#89cadd",
        fillcolor = "#c3e3ed:#cee9f1",
        gradientangle = 90,
        penwidth = 2,
        fontname = "Roboto Medium",
        fontsize = 12,
        shape = circle,
    ]

    # Rows

    40 [YELLOW]
    {rank=same 20, 60}
    {rank=same 10, 30, m40, 50, 70}
    {rank=same left_10, 15, m20, 25, 35, left_50, 55, m60, 65, 75}


    # NULL pointers

    left_10, left_50 [NULL]


    # Invisible padding nodes

    m40, m20, m60, m10, m30, m50, m70 [INVISIBLE_N]


    # Edges

    40 -> 20
    40 -> m40 [INVISIBLE_E]
    40 -> 60

    20 -> 10
    20 -> m20 [INVISIBLE_E]
    20 -> 30

    60 -> 50
    60 -> m60 [INVISIBLE_E]
    60 -> 70

    10 -> left_10
    10 -> m10 [INVISIBLE_E]
    10 -> 15

    30 -> 25
    30 -> m30 [INVISIBLE_E]
    30 -> 35

    50 -> left_50
    50 -> m50 [INVISIBLE_E]
    50 -> 55

    70 -> 65
    70 -> m70 [INVISIBLE_E]
    70 -> 75

}

```

{% endtab %}
{% endtabs %}

{% tabs %}
{% tab title="tree\_basic.png" %}
![](/files/-Ltg-zY9Ixtl-YmepUrN)
{% endtab %}

{% tab title="tree.png" %}
![](/files/-Ltg0uLMeWD5Uw_gFGoz)
{% endtab %}
{% endtabs %}

### Przykład generowania szkicu drzewa za pomocą TikZ/LaTeX

{% tabs %}
{% tab title="tree.tex" %}

```
\documentclass[crop,tikz,10pt]{standalone}

\usepackage{xcolor}

\definecolor{background}{HTML}{F0F4F5}
\definecolor{border}{HTML}{D3E0E3}

\definecolor{blue}{HTML}{1395ba}
\definecolor{dark_blue}{HTML}{0e708c}

\definecolor{pink}{HTML}{f8216e}
\definecolor{dark_pink}{HTML}{b3174e}

\definecolor{yellow}{HTML}{f8ca00}
\definecolor{orange}{HTML}{ff8a39}

\definecolor{green}{HTML}{4fa400}
\definecolor{dark_green}{HTML}{306400}


\usepackage{tikz}
\usetikzlibrary{
    arrows,
    backgrounds,
    positioning,
}

\begin{document}

\begin{tikzpicture}[%
    scale=1.0,
    node distance=0.5cm,
    every node/.style={minimum size=0, inner sep=0},
    on grid,
    background rectangle/.style={draw=border!80!black,fill=background},
    show background rectangle,
    inner frame sep=0.5cm,
    level/.style={
        sibling distance = 5cm/#1,
        level distance = 1.5cm
    },
    every node/.style={
        font=\sffamily\footnotesize,
        circle,
        minimum size=0.6cm,
        line width=0.025cm,
        draw=blue!50,
        top color=blue!20,
        bottom color=blue!30,
    },
    root/.style={
        draw=yellow!50,
        top color=yellow!20,
        bottom color=yellow!30,
    },
    null/.style={
        minimum size=0.2cm,
        inner sep=0,
        draw=black!30,
        top color=black!10,
        bottom color=black!20,
    },
    edge from parent/.style={
        draw,
        pink,
        thick
    }
]

\clip (0, 0) rectangle (10.0, 7.0);

\node [root] at (5, 6) {40}
    child { 
        node {20}
        child {
            node {10}
            child { node [null] {} }
            child { node {15} }
        }
        child {
            node {30}
            child { node {25} }
            child { node {35} }
        }
    }
    child {
        node {60}
        child {
            node {50}
            child { node [null] {} }
            child { node {55} }
        }
        child {
            node {70}
            child { node {65} }
            child { node {75} }
        }
    }
;
 
\end{tikzpicture}
\end{document}

```

{% endtab %}
{% endtabs %}

{% tabs %}
{% tab title="tree.pdf" %}
![](/files/-Ltg8BOP1yY04EXAhtOC)
{% endtab %}
{% endtabs %}

### Pomocne narzędzia

* Na stronie [**viz-js.com**](http://viz-js.com) można poeksperymentować z zapisem w języku *DOT* bezpośrednio w przeglądarce, bez konieczności instalacji pakietu *Graphviz*.
* [**VisuAlgo**](https://visualgo.net/en/bst) zawiera interaktywne wizualizacje drzewa BST, AVL i wielu innych struktur danych i algorytmów.
* W [**repozytorium**](https://github.com/karolpiczak-pw/2019Z-AISDI/tree/master/homework/03-trees) przygotowałem skrypt w *Pythonie,* który pozwala przyspieszyć generowanie wykresów za pomocą *XeLaTeX-u.*

### Forma dostarczenia wyników

Proszę wgrać wynikowe pliki do repozytorium oznaczając je jednoznacznie co do kolejności (np. `bst-00.png`, `...`, `bst-10.png`) lub scalając w jeden obraz/PDF. Nie jest konieczne załączanie plików pomocniczych czy implementacji drzew. Do wizualizacji można wykorzystać również inne dowolne narzędzia. W ostateczności może nimi być kartka i ołówek, ale preferowane są wersje elektroniczne.


# Zadanie domowe #4

{% hint style="danger" %}
Do oceny można zgłosić maksymalnie trzy wybrane zadania domowe.
{% endhint %}

{% hint style="info" %}
Materiały pomocnicze do zadania znajdują się w [repozytorium na GitHub](https://github.com/karolpiczak-pw/2019Z-AISDI/tree/master/homework/04-heaps).
{% endhint %}

**Nazwa repozytorium z rozwiązaniem:** `AISDI-HW 4: Nazwisko`

### Treść zadania

Dla podanego [szablonu klasy kopca binarnego](https://github.com/karolpiczak-pw/2019Z-AISDI/blob/master/homework/04-heaps/minmax_heap.cpp) `ReversibleHeap` proszę zaimplementować metodę `reverse()`, która będzie przełączała działanie kopca pomiędzy wariantem *min-heap* i *max-heap.* Metoda powinna działać w miejscu (*in-place*) w czasie $$O(n)$$.

{% hint style="info" %}
Dla zadania dopuszczalna jest tylko implementacja w C++ na podstawie załączonego szablonu.
{% endhint %}


# 2019Z-AISDI - laboratoria

Algorytmy i struktury danych - zajęcia laboratoryjne

## Prowadzone grupy

* grupa 108, piątki parzyste, 8:15-10:00
* grupa 106, piątki parzyste, 10:15-12:00

## Organizacja zajęć

Laboratoria polegają na rozwiązywaniu przedstawionych zadań w zespołach dwuosobowych. Łącznie za laboratoria do zdobycia jest 30 punktów, po 6 punktów za zadania realizowane na zajęciach 2-6. Do implementacji wykorzystywany jest język C++.

| Lp. | Tematyka zajęć                               | Ocenianie |
| --- | -------------------------------------------- | --------- |
| 1   | zajęcia wstępne, zapoznanie ze środowiskiem  | -         |
| 2   | sortowanie                                   | 6 pkt.    |
| 3   | drzewa                                       | 6 pkt.    |
| 4   | kopce                                        | 6 pkt.    |
| 5   | wyszukiwanie wzorca w tekście                | 6 pkt.    |
| 6   | grafy                                        | 6 pkt.    |
| 7   | termin rezerwowy (oddawanie zaległych zadań) | -         |

## Kryteria oceniania

| Punktacja | Wymagania względem rozwiązania                                                                                                             |
| --------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
| 6 pkt.    | poprawne i kompletne rozwiązanie zadania                                                                                                   |
| 5 pkt.    | rozwiązanie kompletne z niewielkimi uchybieniami (wydajność, przypadki skrajne)                                                            |
| 4 pkt.    | nieliczne błędy implementacyjne o większym znaczeniu, schemat rozwiązania poprawny i kompletny, rozwiązanie wykazuje zrozumienie materiału |
| 3 pkt.    | realizacja części zadania, liczne błędy w implementacji                                                                                    |
| 2 pkt.    | realizacja małej części zadania, liczne błędy w implementacji                                                                              |
| 1 pkt     | realizacja minimalnego zakresu funkcjonalności, bardzo liczne błędy w implementacji                                                        |
| 0 pkt.    | brak zgłoszonego rozwiązania                                                                                                               |

{% hint style="info" %}
Styl kodu oceniany jest w sposób binarny: **akceptowalny (0)**, **niewystarczający (-1)**.
{% endhint %}

{% hint style="info" %}
Poprawki wprowadzone do rozwiązania po zajęciach mogą podnieść punktację co najwyżej o 2 punkty.
{% endhint %}

{% hint style="danger" %}
Błędy dostępu do pamięci (odwoływanie się do nieważnego wskaźnika) traktowane są zawsze jako błędy o większym znaczeniu.
{% endhint %}

## Zasady zgłaszania rozwiązań do oceny

* Rozwiązania zadań laboratoryjnych muszą zostać zaprezentowane na konsultacjach prowadzącemu, do którego są Państwo przypisani w systemie USOS. Grupy mieszane mogą wybrać prowadzącego. Drugim prowadzącym laboratoria jest Waldemar Grabski.
* Przy prezentacji zadania powinien być obecny cały zespół.
* Na konsultacje należy zapisać się w [kalendarzu](https://calendly.com/karolpiczak/) (terminy udostępniane są na najbliższe dwa tygodnie).
* Przy zapisywaniu się **należy podać link do repozytorium na** [**wydziałowym&#x20;*****GitLabie***](https://gitlab-stud.elka.pw.edu.pl/) **ze zgłoszonym&#x20;*****merge request*****&#x20;sporządzonym** [**według instrukcji**](https://files.pw.karolpiczak.com/Instrukcja-GitLab.pdf) o tytule *`AISDI-LAB X: Nazwisko1-Nazwisko2`.*
* Zadania można zdawać do ostatnich zajęć laboratoryjnych. Proszę jednak uwzględnić mniejszą dostępność terminów pod koniec semestru.

{% hint style="info" %}
Na pojedynczych konsultacjach możliwe jest ocenienie więcej niż jednego zadania, z tym że będzie to zależało od ilości uwag i dostępnego czasu. Zwłaszcza w takim przypadku proszę o wcześniejszy kontakt - część uwag postaram się przekazać na zasadzie *code review* przez *GitLab*.
{% endhint %}