常連

注目の的

社会貢献

自己紹介

入門ページを見てやってみたのですが、早速つまずいてしましました。

>>> import pandas as pd
>>> url = 'https://finance.yahoo.com/quote/AAPL/history?p=AAPL&.tsrc=fin-srch'
>>> data = pd.read_html(url, header = 0)


と打っても

Traceback (most recent call last):
  File "<pyshell#7>", line 1, in <module>
    data = pd.read_html(url, header = 0)
  File "C:\Users\■■■■\AppData\Local\Programs\Python\Python38\lib\site-packages\pandas\util\_decorators.py", line 299, in wrapper
    return func(*args, **kwargs)
  File "C:\Users\■■■■\AppData\Local\Programs\Python\Python38\lib\site-packages\pandas\io\html.py", line 1085, in read_html
    return _parse(
  File "C:\Users\■■■■\AppData\Local\Programs\Python\Python38\lib\site-packages\pandas\io\html.py", line 893, in _parse
    tables = p.parse_tables()
  File "C:\Users\■■■■\AppData\Local\Programs\Python\Python38\lib\site-packages\pandas\io\html.py", line 213, in parse_tables
    tables = self._parse_tables(self._build_doc(), self.match, self.attrs)
  File "C:\Users\■■■■\AppData\Local\Programs\Python\Python38\lib\site-packages\pandas\io\html.py", line 732, in _build_doc
    raise e
  File "C:\Users\■■■■\AppData\Local\Programs\Python\Python38\lib\site-packages\pandas\io\html.py", line 713, in _build_doc
    with urlopen(self.io) as f:
  File "C:\Users\■■■■\AppData\Local\Programs\Python\Python38\lib\site-packages\pandas\io\common.py", line 195, in urlopen
    return urllib.request.urlopen(*args, **kwargs)
  File "C:\Users\■■■■\AppData\Local\Programs\Python\Python38\lib\urllib\request.py", line 222, in urlopen
    return opener.open(url, data, timeout)
  File "C:\Users\■■■■\AppData\Local\Programs\Python\Python38\lib\urllib\request.py", line 531, in open
    response = meth(req, response)
  File "C:\Users\■■■■\AppData\Local\Programs\Python\Python38\lib\urllib\request.py", line 640, in http_response
    response = self.parent.error(
  File "C:\Users\■■■■\AppData\Local\Programs\Python\Python38\lib\urllib\request.py", line 569, in error
    return self._call_chain(*args)
  File "C:\Users\■■■■\AppData\Local\Programs\Python\Python38\lib\urllib\request.py", line 502, in _call_chain
    result = func(*args)
  File "C:\Users\■■■■\AppData\Local\Programs\Python\Python38\lib\urllib\request.py", line 649, in http_error_default
    raise HTTPError(req.full_url, code, msg, hdrs, fp)
urllib.error.HTTPError: HTTP Error 404: Not Found


となってしまいます。

pandas
lxml
html5lib
bs4

はインストールしています。

初歩の初歩で一回目でつまずいて情けない限りですが、エラーを検索しても404じゃないかとのことですが、
https://finance.yahoo.com/quote/AAPL/history?p=AAPL&.tsrc=fin-srch は存在しています。
何がいけないのでしょうか…


スクレイピング初歩で躓いています。。。

GPLライセンスについてお聞きしたいです。

私はWEB制作会社に勤めていて、
お客様のHPを作る際に以下のJavaScriptのライブラリを利用しようと思っています。
https://github.com/alvarotrigo/fullPage.js/

こちらのライブラリのライセンスがGPLとなっているのですが、
これを使用してWEBサイトを制作して、
お客様に納品した場合何か問題はありますでしょうか？

GPLライセンスについて調べてみたのですが、
正直よく理解ができなかったため、
こちらでご質問をさせていただきました。

よろしくお願いいたします。

GPLライセンスについて

表題の通りです。

現在、他社が有償で公開しているライブラリがあるのですが、自身で開発できそうな機能だなと思っています。
また、当該ライブラリは汎用的なものであるため多くの人に使って貰えればと思い、OSSとしてGithubで公開できればとも考えています。

この場合、ライセンスの絡みが問題になってくるかと思いますが、具体的にどのような問題が生まれるか気になっています。

細かいことは弁護士等の専門家に聞こうと思っていますが、前提知識としてざっくりどの様な点に留意すべきか、
個人で公開する場合/会社として公開する場合の違いなど、ライセンス周りに詳しい方、似た様な経験をされた方が
いればアドバイスをいただきたいです。

他社が有償販売しているソフトウェアと同様の機能を自分で開発してOSSとして公開することの問題点について

OSSのライセンスの解釈に悩んでおり、Webの情報を見ると「専門家に相談した方が良い」という記載をよく見かけます。
この場合の専門家とは、どこに相談すると良いのでしょうか？
商用利用の相談であるため、相談に費用が掛かる場合も選択肢に入ります。

判断材料になるかもしれないので、相談したい内容も以下に記載します。

自社で開発しているソフトウェアの内部で使用するDBとして、MongoDBを使用させてもらいたいと考えています。
DB自体をサービスとして提供するということではなく、あくまで自社開発しているソフトウェアの中で、内部データを保持するためのDBとして使います。
その目的のため、MongoDBを自社開発ソフトウェアのインストーラに含めて再配布しようと考えています。

以上の用途であればMongoDBのSSPLライセンスでの配布が可能であり、かつ自社開発ソフトウェアにはSSPLライセンスは伝播しないと考えています。
特に心配しているのは、その「伝播しない」が正しいかどうかです。（もちろん、ライセンス情報を記載する等の、同梱における他の義務は果たす前提です）

以上のような内容を専門家に相談したく、しかし専門家とは誰なのだろうという点で悩んでいます。
汎用的な答えでなくても「自分はこうしている」という情報をもらえるだけでも助かりますので、ご協力お願いします。

OSSの商用利用について、専門家への相談はどこに相談するのが良いのでしょうか？

### 実現したいこと
とある、OSSライセンスGPLv3が適用されたJSライブラリをベースに独自の関数を追加しただけの追記を行い、Webサーバー経由でのホスティングとソースコードの公開を行いたいです。

GPLv3はコピーレフト型のOSSライセンスとのことですが、一部追記したJSライブラリを含めた静的Webサイトを構成するソースコード（以下成果物）をWebサーバー経由でホスティングし、なおかつソースコードをサイトで公開するためには、GPLv3のOSSライセンスを成果物にも継承して適用する必要があるのでしょうか？

また、追記部分に改変したことを示すコメントを挿入する必要はありますでしょうか？

自分なりに調べたところ、成果物全体に対してGPLv3を継承し、改変したことを示すコメントを挿入する必要があるという解釈でいますが、GPLv3を継承する必要があるのか、改変したことを示すコメントとは具体的にどのようなもの（目立つように多くの行数を必要とするのかなど）なのか、疑問が多く自信が持てません。

どうかお詳しい方がおられれば教えていただけますでしょうか。

OSSライセンスGPLv3が適用されたJSライブラリを改変して利用した場合の扱いに関して

### 基本情報技術者試験についてです。

過去問の平成25年度秋期問21
「GPLの下で公開されたOSSを使い、ソースコードを公開しなかった場合にライセンス違反となるものはどれか。

ア OSSとアプリケーションソフトウェアとのインタフェースを開発し、販売している。
イ OSSの改変を他社に委託し、自社内で使用している。
ウ OSSの入手、改変、販売を全て自社で行っている。
エ OSSを利用して性能テストを行った自社開発ソフトウェアを販売している。

答えはウです。

解説には、GPLのソフトを改変してアプリケーションソフトを作成した場合は頒布先にソースコードを公開する。とありますがなぜウが答えなのでしょうか？
アとエは改変していないので違うということはわかりますが、イは改変しているのに答えではない。自社がAで他社がBだとして、AがBに改変を委託して、それをAが自社内で使っているため、BはAにソースコードを公開したという判断なんでしょうか？

この解釈でいいのでしょうか？ご教授願います。

OSSのGPLについての問題がわかりません。

OSSをフォークした際のライセンスの表記についてです。

フォークした物を改変・公開する際、元のライセンス表記はライセンス上必要であれば残すとして
改変者の名前はどのように表記すればよいでしょうか？（あるいは、表記する必要はないでしょうか？）

MITライセンスなど無保証のライセンスを利用していても、バグ報告などの受付は行いたいので
自分の名前、連絡先を表記したいと思った次第です。

ご回答よろしくお願いします。

---
追記:

現状、ライセンス表記の名前と連名にするか、ライセンス表記の近くに「私が改変しましたー」という表記を載せたりしています。

元のソースコードがわからなくなるほどの改変の場合、
フォークをやめて新しいライブラリとしてライセンス表記そのものを書き換えるか、
上述のような表記をするか悩むところです…

---
追記2:

既存のソフトウェア/ライブラリの改変版を公開する場合です。元のライセンスはMITライセンスです。

OSSフォーク時のライセンス表記について

DNN分野では「End-to-end training」という言葉がよく出てきますが、
公式的な解釈はなく、個別な解釈を読んでも、分かるような分からないような気分です。

原因は恐らく反対の概念**「End-to-endではないtraining」**は何ですか
というのは分かっていないためかなと思います。

どなたかご解釈いただけませんか。

「End-to-end training」 とは？

[機械学習／ディープラーニングにおけるバッチサイズ、イテレーション数、エポック数の決め方](https://qiita.com/kenta1984/items/bad75a37d552510e4682)の

> この幾つかに分けたぞれぞれのサブセットに含まれるデータの数をバッチサイズと呼びます。

を見て、batchsizeは一度に見るサンプルの数であると分かったので(他サイトでも同じような説明がなされていました)、``classifier.fit()``の``batch_size = 1``のパラメータをいじって挙動を見てみると``batch_size = 1``よりも``batch_size = 100``の方が学習速度が速く、``batch_size = 1000000000``にすると学習速度が飛躍的に早くなりました。バッチサイズがサブセットに含まれるデータ数なら、455行しか持たない時点でエラーが起きるはずですし(データセットを超える量のデータを一度に学習している)、そもそも一度に1000000000ものデータを学習するとかなり学習速度が遅くなると予想していたのですが、予想に反して学習速度が速くなりました。これはなぜでしょうか？ちなみに、学習結果であるCorrectはbatch_sizeにかかわらずCorrect=114なので全問正解でした




```
import pandas as pd

X_train = pd.read_csv("C:\Users\hoge\demo\YouTube_tutorial/xtrain.csv", header=None)
Y_train = pd.read_csv("C:\Users\hoge\demo\YouTube_tutorial/ytrain.csv", header=None)
X_test = pd.read_csv("C:\Users\hoge\demo\YouTube_tutorial/xtest.csv", header=None)
Y_test = pd.read_csv("C:\Users\hoge\demo\YouTube_tutorial/ytest.csv", header=None)
from keras.models import Sequential
from keras.layers import Dense

classifier = Sequential()

classifier.add(Dense(units = 16, activation = 'relu', input_dim = 30))
classifier.add(Dense(units = 8, activation = 'relu'))
classifier.add(Dense(units = 6, activation = 'relu'))
classifier.add(Dense(units = 1, activation = 'sigmoid'))


classifier.compile(optimizer = 'rmsprop', loss = 'binary_crossentropy')

```
```
print(X_train.shape)
print(Y_train.shape)
print(X_test.shape)
print(Y_test.shape)

>>> (455, 30)
>>> (455, 1)
>>> (114, 30)
>>> (114, 1)

```



```

classifier.fit(X_train, Y_train, batch_size = 1, epochs = 100)
と
classifier.fit(X_train, Y_train, batch_size = 100, epochs = 100)
と
classifier.fit(X_train, Y_train, batch_size = 1000000000, epochs = 100)
```


```
Y_pred = classifier.predict(X_test)
Y_pred = [ 1 if y>=0.5 else 0 for y in Y_pred]

total = 0
correct = 0
wrong = 0
for i in Y_pred:
    total=total+1
    if(Y_test.at[i, 0] == Y_pred[i]):
        correct=correct+1
    else:
        wrong=wrong+1
        
print("Total" + str(total))
print("Correct" + str(correct))
print("Wrong" + str(wrong))


>>> Total114
>>> Correct114
>>> Wrong0
```






### 試したこと
[機械学習／ディープラーニングにおけるバッチサイズ、イテレーション数、エポック数の決め方](https://qiita.com/kenta1984/items/bad75a37d552510e4682)を見て理解する

batch_sizeの調整

皆様、質問がございます、よろしくお願い申し上げます。


```
"Github"
https://github.com/mackenziechild/pinterest_clone
```

```
質問
上記リポジトリのコードは、コードの一部を利用して良いという旨が書かれていないため
第三者による利用を許可していないのでしょうか？？
Githubにおける著作権のあり方が理解仕切れていないため質問いたします。
```

よろしくお願い申し上げます。

Githubの著作権に関して

私はちょくちょくQiitaに記事を執筆することがあります。

そこで疑問に思ったのですが、例えば本でプログラミング学習していて、
その本のコードの内容はGitHubに全て公開されている状態だとします。
そして、インターネットで`「本のタイトル」　GitHub`などと検索すると誰でも内容を確認できるものとします。

例えばデータについてはスクレイピングなどして自分でとって来た場合、
実装についてコードの一部を自分の記事の中でまるまる使用しても、
参照元をGitHubのURLにしてしまえば問題ないのでしょうか？

本、GitHubの著作権について

**ボールドテキスト**
### 前提・実現したいこと

Yolov4を用いたDeepSortでのTrackingでの1度検出された物体にずっと同じIDを振り続けたい

### 発生している問題・エラーメッセージ

```
動画が少し動いたりするとIDが更新され番号が変わったりする。
```

### 該当のソースコード

```Python
flags.DEFINE_float('iou', 0.45, 'iou threshold')
flags.DEFINE_float('score', 0.50, 'score threshold')
flags.DEFINE_boolean('dont_show', False, 'dont show video output')
flags.DEFINE_boolean('info', False, 'show detailed info of tracked objects')
flags.DEFINE_boolean('count', False, 'count objects being tracked on screen')

def main(_argv):
    # Definition of the parameters
    max_cosine_distance = 0.4
    nn_budget = None
    nms_max_overlap = 1.0
    
    # initialize deep sort
    model_filename = 'model_data/mars-small128.pb'
    encoder = gdet.create_box_encoder(model_filename, batch_size=1)
    # calculate cosine distance metric
    metric = nn_matching.NearestNeighborDistanceMetric("cosine", max_cosine_distance, nn_budget)
    # initialize tracker
    tracker = Tracker(metric)

    # load configuration for object detector
    config = ConfigProto()
    config.gpu_options.allow_growth = True
    session = InteractiveSession(config=config)
    STRIDES, ANCHORS, NUM_CLASS, XYSCALE = utils.load_config(FLAGS)
    input_size = FLAGS.size
    video_path = FLAGS.video

    # load tflite model if flag is set
    if FLAGS.framework == 'tflite':
        interpreter = tf.lite.Interpreter(model_path=FLAGS.weights)
        interpreter.allocate_tensors()
        input_details = interpreter.get_input_details()
        output_details = interpreter.get_output_details()
        print(input_details)
        print(output_details)
    # otherwise load standard tensorflow saved model
    else:
        saved_model_loaded = tf.saved_model.load(FLAGS.weights, tags=[tag_constants.SERVING])
        infer = saved_model_loaded.signatures['serving_default']

    # begin video capture
    try:
        vid = cv2.VideoCapture(int(video_path))
    except:
        vid = cv2.VideoCapture(video_path)

    out = None

    # get video ready to save locally if flag is set
    if FLAGS.output:
        # by default VideoCapture returns float instead of int
        width = int(vid.get(cv2.CAP_PROP_FRAME_WIDTH))
        height = int(vid.get(cv2.CAP_PROP_FRAME_HEIGHT))
        fps = int(vid.get(cv2.CAP_PROP_FPS))
        codec = cv2.VideoWriter_fourcc(*FLAGS.output_format)
        out = cv2.VideoWriter(FLAGS.output, codec, fps, (width, height))

    frame_num = 0
    # while video is running
    while True:
        return_value, frame = vid.read()
        if return_value:
            frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
            image = Image.fromarray(frame)
        else:
            print('Video has ended or failed, try a different video format!')
            break
        frame_num +=1
        print('Frame #: ', frame_num)
        frame_size = frame.shape[:2]
        image_data = cv2.resize(frame, (input_size, input_size))
        image_data = image_data / 255.
        image_data = image_data[np.newaxis, ...].astype(np.float32)
        start_time = time.time()

        # run detections on tflite if flag is set
        if FLAGS.framework == 'tflite':
            interpreter.set_tensor(input_details[0]['index'], image_data)
            interpreter.invoke()
            pred = [interpreter.get_tensor(output_details[i]['index']) for i in range(len(output_details))]
            # run detections using yolov3 if flag is set
            if FLAGS.model == 'yolov3' and FLAGS.tiny == True:
                boxes, pred_conf = filter_boxes(pred[1], pred[0], score_threshold=0.25,
                                                input_shape=tf.constant([input_size, input_size]))
            else:
                boxes, pred_conf = filter_boxes(pred[0], pred[1], score_threshold=0.25,
                                                input_shape=tf.constant([input_size, input_size]))
        else:
            batch_data = tf.constant(image_data)
            pred_bbox = infer(batch_data)
            for key, value in pred_bbox.items():
                boxes = value[:, :, 0:4]
                pred_conf = value[:, :, 4:]

        boxes, scores, classes, valid_detections = tf.image.combined_non_max_suppression(
            boxes=tf.reshape(boxes, (tf.shape(boxes)[0], -1, 1, 4)),
            scores=tf.reshape(
                pred_conf, (tf.shape(pred_conf)[0], -1, tf.shape(pred_conf)[-1])),
            max_output_size_per_class=50,
            max_total_size=50,
            iou_threshold=FLAGS.iou,
            score_threshold=FLAGS.score
        )

        # convert data to numpy arrays and slice out unused elements
        num_objects = valid_detections.numpy()[0]
        bboxes = boxes.numpy()[0]
        bboxes = bboxes[0:int(num_objects)]
        scores = scores.numpy()[0]
        scores = scores[0:int(num_objects)]
        classes = classes.numpy()[0]
        classes = classes[0:int(num_objects)]

        # format bounding boxes from normalized ymin, xmin, ymax, xmax ---> xmin, ymin, width, height
        original_h, original_w, _ = frame.shape
        bboxes = utils.format_boxes(bboxes, original_h, original_w)

        # store all predictions in one parameter for simplicity when calling functions
        pred_bbox = [bboxes, scores, classes, num_objects]

        # read in all class names from config
        class_names = utils.read_class_names(cfg.YOLO.CLASSES)

        # by default allow all classes in .names file
        allowed_classes = list(class_names.values())
        
        # custom allowed classes (uncomment line below to customize tracker for only people)
        #allowed_classes = ['person']

        # loop through objects and use class index to get class name, allow only classes in allowed_classes list
        names = []
        deleted_indx = []
        for i in range(num_objects):
            class_indx = int(classes[i])
            class_name = class_names[class_indx]
            if class_name not in allowed_classes:
                deleted_indx.append(i)
            else:
                names.append(class_name)
        names = np.array(names)
        count = len(names)
        if FLAGS.count:
            cv2.putText(frame, "Objects being tracked: {}".format(count), (5, 35), cv2.FONT_HERSHEY_COMPLEX_SMALL, 2, (0, 255, 0), 2)
            print("Objects being tracked: {}".format(count))
        # delete detections that are not in allowed_classes
        bboxes = np.delete(bboxes, deleted_indx, axis=0)
        scores = np.delete(scores, deleted_indx, axis=0)

        # encode yolo detections and feed to tracker
        features = encoder(frame, bboxes)
        detections = [Detection(bbox, score, class_name, feature) for bbox, score, class_name, feature in zip(bboxes, scores, names, features)]

        #initialize color map
        cmap = plt.get_cmap('tab20b')
        colors = [cmap(i)[:3] for i in np.linspace(0, 1, 20)]

        # run non-maxima supression
        boxs = np.array([d.tlwh for d in detections])
        scores = np.array([d.confidence for d in detections])
        classes = np.array([d.class_name for d in detections])
        indices = preprocessing.non_max_suppression(boxs, classes, nms_max_overlap, scores)
        detections = [detections[i] for i in indices]       

        # Call the tracker
        tracker.predict()
        tracker.update(detections)

        # update tracks
        for track in tracker.tracks:
            if not track.is_confirmed() or track.time_since_update > 1:
                continue 
            bbox = track.to_tlbr()
            class_name = track.get_class()
            
        # draw bbox on screen
            color = colors[int(track.track_id) % len(colors)]
            color = [i * 255 for i in color]
            cv2.rectangle(frame, (int(bbox[0]), int(bbox[1])), (int(bbox[2]), int(bbox[3])), color, 2)
            cv2.rectangle(frame, (int(bbox[0]), int(bbox[1]-30)), (int(bbox[0])+(len(class_name)+len(str(track.track_id)))*17, int(bbox[1])), color, -1)
            cv2.putText(frame, class_name + "-" + str(track.track_id),(int(bbox[0]), int(bbox[1]-10)),0, 0.75, (255,255,255),2)

        # if enable info flag then print details about each track
            if FLAGS.info:
                print("Tracker ID: {}, Class: {},  BBox Coords (xmin, ymin, xmax, ymax): {}".format(str(track.track_id), class_name, (int(bbox[0]), int(bbox[1]), int(bbox[2]), int(bbox[3]))))

        # calculate frames per second of running detections
        fps = 1.0 / (time.time() - start_time)
        print("FPS: %.2f" % fps)
        result = np.asarray(frame)
        result = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
        
        if not FLAGS.dont_show:
            cv2.imshow("Output Video", result)
        
        # if output flag is set, save video file
        if FLAGS.output:
            out.write(result)
        if cv2.waitKey(1) & 0xFF == ord('q'): break
    cv2.destroyAllWindows()

if __name__ == '__main__':
    try:
        app.run(main)
    except SystemExit:
        pass

```

### 試したこと

閾値の値などを変えたが流石にできなかったので直近で消えたIDをその後すぐ出てきた新しい物体に同じIDを振りたい

### 補足情報（FW/ツールのバージョンなど）
ソースなどはこの方を使用させていただいています
https://github.com/theAIGuysCode/yolov4-deepsort/blob/master/object_tracker.py
この方のqiitaの途中で出てくるEnd2Newというような機能を追加してあげたい
https://qiita.com/ComputerVision/items/fc64317006c25f37cc3e

Yoloでの同じ物体に対してIDが複数回与えられてしまう

YOLOv3でリアルタイムな人物の検出を行いたいと考えています。
分類するクラスを少なくすることで速度は向上しますか？
また、クラス数を減らすことのデメリットは存在しますか？
回答よろしくお願いいたします。

映像中の人物の検出を高速に精度良く行いたいです。深層学習での物体検出を行うとき、クラス数を減らして学習すると速度は向上しますか？

### 前提・実現したいこと
yolov2を用いて精度の良い物体検出をしたいと考えています。
検出する物をcarのみにしたい為、class_namesを変更など試しているのですが指定した物以外も検出されてしまいます。
なにかやり方があれば教えていただきたいです。
### 該当のソースコード

```ここに言語名を入力
from darkflow.net.build import TFNet
import cv2
import numpy as np

options = {"model": "yolov2-tiny-voc.cfg", "load": "yolov2-tiny-voc.weights", "threshold": 0.1,"GPU": 1.0}
tfnet = TFNet(options)

# カメラの起動
cap = cv2.VideoCapture(r"C:\Script\_home_pi_movie__home_pi_movie_cap20201004_1411.mp4")

class_names = ["aeroplane", "bicycle", "bird", "boat", "bottle",
    "bus", "car", "cat", "chair", "cow", "diningtable", "dog",
    "horse", "motorbike", "person", "pottedplant", "sheep", "sofa",
    "train", "tvmonitor"]

width = int(cap.get(3))
height = int(cap.get(4))
fourcc = cv2.VideoWriter_fourcc('H','2','6','4')
out = cv2.VideoWriter('tesaaat.mp4',fourcc, 15, (width,height))

num_classes = len(class_names)
class_colors = []
for i in range(0, num_classes):
    hue = 255*i/num_classes
    col = np.zeros((1,1,3)).astype("uint8")
    col[0][0][0] = hue
    col[0][0][1] = 128
    col[0][0][2] = 255
    cvcol = cv2.cvtColor(col, cv2.COLOR_HSV2BGR)
    col = (int(cvcol[0][0][0]), int(cvcol[0][0][1]), int(cvcol[0][0][2]))
    class_colors.append(col) 
    
def main():
    
    while(True):
        
        # 動画ストリームからフレームを取得
        ret, frame = cap.read()
        result = tfnet.return_predict(frame)
        #cv2.line(frame, (0, pos_linha), (1280, pos_linha), (255,127,0), 1) #線

        for item in result:
            tlx = item['topleft']['x']
            tly = item['topleft']['y']
            brx = item['bottomright']['x']
            bry = item['bottomright']['y']
            label = item['label']
            conf = item['confidence']

            if conf > 0.5:
                
                for i in class_names:
                    if label == i and class_names[7] == label:
                        class_num = class_names.index(i)
                        break
                
                #枠の作成
                cv2.rectangle(frame, (tlx, tly), (brx, bry), class_colors[class_num], 2)
                #ラベルの作成
                text = label + " " + ('%.2f' % conf)  
                cv2.rectangle(frame, (tlx, tly - 15), (tlx + 100, tly + 5), class_colors[class_num], -1)
                cv2.putText(frame, text, (tlx, tly), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0,0,0), 1)

        # 表示
        cv2.imshow("Show FLAME Image", frame)
        out.write(frame)

        # escを押したら終了。
        k = cv2.waitKey(10);
        if k == ord('q'):  break;

    cap.release()
    out.release()
    cv2.destroyAllWindows()
    
if __name__ == '__main__':
    main()
```

YOLO 特定のクラスだけ検出したい

### 前提・実現したいこと

YOLOv4でのDeepSortをしているのですが出力結果のところに座標、FPS、検出されている物体名、IDは出力できています。これらにプラスで切り取られているフレームでの動画の再生時間？？を求めたいのですがどのように書いたらいいのかわかりません
### 現在出力されているtxt
Frame #:  1
FPS: 0.57
Frame #:  2
FPS: 41.59
Frame #:  3
Tracker ID: 1, Class: KPHN,  BBox Coords (xmin, ymin, xmax, ymax): (866, 800, 965, 850)
Tracker ID: 2, Class: KPHN,  BBox Coords (xmin, ymin, xmax, ymax): (796, 850, 851, 904)
FPS: 42.47

```
上記はFrame4までですが全部で2588Frameあります
自分が表記したい感じは
Frame #:  1
FPS: 0.57
Time:0.0001
Frame #:  2
FPS: 41.59
Time:0.0002
Frame #:  3
Tracker ID: 1, Class: KPHN,  BBox Coords (xmin, ymin, xmax, ymax): (866, 800, 965, 850)
Tracker ID: 2, Class: KPHN,  BBox Coords (xmin, ymin, xmax, ymax): (796, 850, 851, 904)
FPS: 42.47
Time:0.0003

このような感じで出したいと思ってます（時間は適当に表記しました）
```

### 該当のソースコード

```python
def main(_argv):
    # Definition of the parameters
    max_cosine_distance = 0.4
    nn_budget = None
    nms_max_overlap = 1.0
    
    # initialize deep sort
    model_filename = 'model_data/mars-small128.pb'
    encoder = gdet.create_box_encoder(model_filename, batch_size=1)
    # calculate cosine distance metric
    metric = nn_matching.NearestNeighborDistanceMetric("cosine", max_cosine_distance, nn_budget)
    # initialize tracker
    tracker = Tracker(metric)

    # load configuration for object detector
    config = ConfigProto()
    config.gpu_options.allow_growth = True
    session = InteractiveSession(config=config)
    STRIDES, ANCHORS, NUM_CLASS, XYSCALE = utils.load_config(FLAGS)
    input_size = FLAGS.size
    video_path = FLAGS.video

    # load tflite model if flag is set
    if FLAGS.framework == 'tflite':
        interpreter = tf.lite.Interpreter(model_path=FLAGS.weights)
        interpreter.allocate_tensors()
        input_details = interpreter.get_input_details()
        output_details = interpreter.get_output_details()
        print(input_details)
        print(output_details)
    # otherwise load standard tensorflow saved model
    else:
        saved_model_loaded = tf.saved_model.load(FLAGS.weights, tags=[tag_constants.SERVING])
        infer = saved_model_loaded.signatures['serving_default']

    # begin video capture
    try:
        vid = cv2.VideoCapture(int(video_path))
    except:
        vid = cv2.VideoCapture(video_path)

    out = None

    # get video ready to save locally if flag is set
    if FLAGS.output:
        # by default VideoCapture returns float instead of int
        width = int(vid.get(cv2.CAP_PROP_FRAME_WIDTH))
        height = int(vid.get(cv2.CAP_PROP_FRAME_HEIGHT))
        fps = int(vid.get(cv2.CAP_PROP_FPS))
        codec = cv2.VideoWriter_fourcc(*FLAGS.output_format)
        out = cv2.VideoWriter(FLAGS.output, codec, fps, (width, height))

    frame_num = 0
    # while video is running
    while True:
        return_value, frame = vid.read()
        if return_value:
            frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
            image = Image.fromarray(frame)
        else:
            print('Video has ended or failed, try a different video format!')
            break
        frame_num +=1
        print('Frame #: ', frame_num)
        frame_size = frame.shape[:2]
        image_data = cv2.resize(frame, (input_size, input_size))
        image_data = image_data / 255.
        image_data = image_data[np.newaxis, ...].astype(np.float32)
        start_time = time.time()

        # run detections on tflite if flag is set
        if FLAGS.framework == 'tflite':
            interpreter.set_tensor(input_details[0]['index'], image_data)
            interpreter.invoke()
            pred = [interpreter.get_tensor(output_details[i]['index']) for i in range(len(output_details))]
            # run detections using yolov3 if flag is set
            if FLAGS.model == 'yolov3' and FLAGS.tiny == True:
                boxes, pred_conf = filter_boxes(pred[1], pred[0], score_threshold=0.25,
                                                input_shape=tf.constant([input_size, input_size]))
            else:
                boxes, pred_conf = filter_boxes(pred[0], pred[1], score_threshold=0.25,
                                                input_shape=tf.constant([input_size, input_size]))
        else:
            batch_data = tf.constant(image_data)
            pred_bbox = infer(batch_data)
            for key, value in pred_bbox.items():
                boxes = value[:, :, 0:4]
                pred_conf = value[:, :, 4:]

        boxes, scores, classes, valid_detections = tf.image.combined_non_max_suppression(
            boxes=tf.reshape(boxes, (tf.shape(boxes)[0], -1, 1, 4)),
            scores=tf.reshape(
                pred_conf, (tf.shape(pred_conf)[0], -1, tf.shape(pred_conf)[-1])),
            max_output_size_per_class=50,
            max_total_size=50,
            iou_threshold=FLAGS.iou,
            score_threshold=FLAGS.score
        )

        # convert data to numpy arrays and slice out unused elements
        num_objects = valid_detections.numpy()[0]
        bboxes = boxes.numpy()[0]
        bboxes = bboxes[0:int(num_objects)]
        scores = scores.numpy()[0]
        scores = scores[0:int(num_objects)]
        classes = classes.numpy()[0]
        classes = classes[0:int(num_objects)]

        # format bounding boxes from normalized ymin, xmin, ymax, xmax ---> xmin, ymin, width, height
        original_h, original_w, _ = frame.shape
        bboxes = utils.format_boxes(bboxes, original_h, original_w)

        # store all predictions in one parameter for simplicity when calling functions
        pred_bbox = [bboxes, scores, classes, num_objects]

        # read in all class names from config
        class_names = utils.read_class_names(cfg.YOLO.CLASSES)

        # by default allow all classes in .names file
        allowed_classes = list(class_names.values())
        
        # custom allowed classes (uncomment line below to customize tracker for only people)
        #allowed_classes = ['person']

        # loop through objects and use class index to get class name, allow only classes in allowed_classes list
        names = []
        deleted_indx = []
        for i in range(num_objects):
            class_indx = int(classes[i])
            class_name = class_names[class_indx]
            if class_name not in allowed_classes:
                deleted_indx.append(i)
            else:
                names.append(class_name)
        names = np.array(names)
        count = len(names)
        if FLAGS.count:
            cv2.putText(frame, "Objects being tracked: {}".format(count), (5, 35), cv2.FONT_HERSHEY_COMPLEX_SMALL, 2, (0, 255, 0), 2)
            print("Objects being tracked: {}".format(count))
        # delete detections that are not in allowed_classes
        bboxes = np.delete(bboxes, deleted_indx, axis=0)
        scores = np.delete(scores, deleted_indx, axis=0)

        # encode yolo detections and feed to tracker
        features = encoder(frame, bboxes)
        detections = [Detection(bbox, score, class_name, feature) for bbox, score, class_name, feature in zip(bboxes, scores, names, features)]

        #initialize color map
        cmap = plt.get_cmap('tab20b')
        colors = [cmap(i)[:3] for i in np.linspace(0, 1, 20)]

        # run non-maxima supression
        boxs = np.array([d.tlwh for d in detections])
        scores = np.array([d.confidence for d in detections])
        classes = np.array([d.class_name for d in detections])
        indices = preprocessing.non_max_suppression(boxs, classes, nms_max_overlap, scores)
        detections = [detections[i] for i in indices]       

        # Call the tracker
        tracker.predict()
        tracker.update(detections)

        # update tracks
        for track in tracker.tracks:
            if not track.is_confirmed() or track.time_since_update > 1:
                continue 
            bbox = track.to_tlbr()
            class_name = track.get_class()
            
        # draw bbox on screen
            color = colors[int(track.track_id) % len(colors)]
            color = [i * 255 for i in color]
            cv2.rectangle(frame, (int(bbox[0]), int(bbox[1])), (int(bbox[2]), int(bbox[3])), color, 2)
            cv2.rectangle(frame, (int(bbox[0]), int(bbox[1]-30)), (int(bbox[0])+(len(class_name)+len(str(track.track_id)))*17, int(bbox[1])), color, -1)
            cv2.putText(frame, class_name + "-" + str(track.track_id),(int(bbox[0]), int(bbox[1]-10)),0, 0.75, (255,255,255),2)

        # if enable info flag then print details about each track
            if FLAGS.info:
                print("Tracker ID: {}, Class: {},  BBox Coords (xmin, ymin, xmax, ymax): {}".format(str(track.track_id), class_name, (int(bbox[0]), int(bbox[1]), int(bbox[2]), int(bbox[3]))))

        # calculate frames per second of running detections
        fps = 1.0 / (time.time() - start_time)
        print("FPS: %.2f" % fps)
        result = np.asarray(frame)
        result = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
        
        if not FLAGS.dont_show:
            cv2.imshow("Output Video", result)
        
        # if output flag is set, save video file
        if FLAGS.output:
            out.write(result)
        if cv2.waitKey(1) & 0xFF == ord('q'): break
    cv2.destroyAllWindows()

if __name__ == '__main__':
    try:
        app.run(main)
    except SystemExit:
        pass
```



### 補足情報（FW/ツールのバージョンなど）
文字数制限でソースが書ききれませんでした。
のでimportなどの部分は抜いて表記しましたが全部見たい方がいましたらお手数ですが
下のGIT内のobject_tracker.pyを見てご回答いただけると助かります
こちらの方のGitを参考に使わせていただいています
https://github.com/theAIGuysCode/yolov4-deepsort

Yolov4を用いたDeepSortの各フレームの動画時間をtxtに出力したい

### 前提
CNNで物を認識する場合対象のサイズに依存することは分かりました。
ところがTEST画像の中に認識してほしいobjectのサイズは必ずしもCNNをトレーニングするに使われる学習画像中の対するobjectのサイズと一致する訳ではない。
そのために、●「複数の**サイズの異なるobject画像**をCNNに学習させればOK」という説がありました。

### 質問の内容

**質問１**
CNNの入力に画像サイズまちまちで可能でしょうか。
まちまちで不可能であれば、どうやって異なるサイズのobject画像を学習させるのでしょうか。


**質問２**
仮に、**異なるサイズ**のobject画像をCNNに入力できるとします。
そうしたら、同じobjectであってもobjectの画像サイズが違えれば、CNN自身が画像の**scale不変特徴量**を抽出できないので、objectの特徴が全然違う事になります。
つまり、**多量の異なる特徴量に同じラベルを持つ**事になります。
それに**多量のラベルが存在**します。
このような状況にNNが**混乱しない**でしょうか-----どうして耐えられるのでしょうか。

CNNで異なるサイズのobject認識問題

### 前提,質問したいこと

現在YOLOv3を独自データセットで学習することに取り組んでいるのですが、知らべても理解できなかったことがあるので質問させていただきます。

現在、下記のサイトを参考にオリジナルデータでの学習はできたのですが、以下のコマンドでyolov3のweightsをダウンロードしてきてからkeras用に変換しているところの詳細が分かりません。
wget https://pjreddie.com/media/files/yolov3.weights
python convert.py -w yolov3.cfg yolov3.weights model_data/yolo_weights.h5

そこで、質問なのですが
yolov3.weightsはCOCOデータセットで学習された80種類の物体を検出できる重みのネットワークということなのでしょうか。
また、今回私はこの80種類には含まれない物体を学習させたのですが、このネットワークのどの層の重みを学習し直しているのでしょうか。(すべての重みなのか一部分だけなのか)
また、yolov3で独自データで学習させるネットワークとはdarknet53のことなのでしょうか。

見当違いのことを言ってしまっているかもしれませんが、教えていただけると助かります。何卒宜しくお願い致します。






### 補足情報（FW/ツールのバージョンなど）

参考にしたサイト
https://sleepless-se.net/2019/06/21/how-to-train-keras%E2%88%92yolo3/

yolov3でオリジナルデータでの学習の仕組み(keras)

kerasにて画像の判別機を作成しております。
学習データの精度の偏りを見るためにクラスごとの精度をグラフ表示したいのですが、どのようにしたらいいでしょうか？

```python 
# coding:utf-8

import keras
from keras.utils import np_utils
from keras.layers.convolutional import Conv2D, MaxPooling2D
from keras.models import Sequential
from keras.layers.core import Dense, Dropout, Activation, Flatten
from keras.preprocessing.image import array_to_img, img_to_array, list_pictures, load_img
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
from keras.preprocessing.image import ImageDataGenerator
from keras.preprocessing import image



#【学習データの読み込み】
X = []
Y = []#category_name
datagen = ImageDataGenerator(horizontal_flip=True)
max_img_num = 10


# a画像
for picture in list_pictures('dir/pic/a'):
    img = img_to_array(load_img(picture, target_size=(32,32)))
    X.append(img)
    Y.append(0)

# b画像
for picture in list_pictures('/dir/pic/b'):
    img = img_to_array(load_img(picture, target_size=(32,32)))
    X.append(img)
    X.append(img2)

    Y.append(1)

# 画素値を0から1の範囲に変換
X = X.astype('float32')
X = X / 255.0

# クラスの形式を変換
Y = np_utils.to_categorical(Y, 1)

# 学習用データとテストデータ
X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.2)

# 【CNNを構築】
model = Sequential()

model.add(Conv2D(32, (3, 3), padding='same',
                 input_shape=X_train.shape[1:]))

model.add(Activation('relu'))
model.add(Conv2D(32, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Conv2D(64, (3, 3), padding='same'))
model.add(Activation('relu'))
model.add(Conv2D(64, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))

model.add(Flatten())
model.add(Dense(512))
model.add(Activation('relu'))
model.add(Dropout(0.6))
model.add(Dense(2))
model.add(Activation('softmax'))

# 【コンパイル】
model.compile(loss='categorical_crossentropy',#損失関数
              optimizer='adam',#最適化、オブジェクト
              metrics=['accuracy'])#評価関数、正解率

#【学習実行】
history = model.fit(X_train, y_train, batch_size=64, epochs=1,
                   validation_data = (X_test, y_test), verbose = 1)


score = model.evaluate(X_test, y_test, verbose = 1)
print("正解", score[1], "loss", score[0])

#【学習をグラフ表示】
%matplotlib inline
plt.plot(history.history['acc'])
plt.plot(history.history['val_acc'])
plt.title('model accuracy')
plt.legend(['train', 'test'], loc='upper left')
plt.show()    
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.title('model loss')
plt.legend(['loss', 'val_loss'], loc='upper left')
plt.show()

```

この場合aとbの画像に対しての精度を見たいです。

宜しくお願い致します。

keras クラスごとの精度

お椀を側面から撮影を行って, 画像からお椀の側面の面積を算出させたいです.

外接矩形を用いると, 高さと上辺の長さしか求まらないので, 面積を算出することができずに悩んでおります.
面積を求める際に, 台形の端点となる座標(x, y)の値を求める方法がございましたらご教授願います.



![イメージ説明](ef796751e584d404c480af6309713208.jpeg)

Pythonを用いて面積を算出したいです.

### 前提・実現したいこと
私はPython を用いて面積を求めようと考えております。
方法としては、面積が既知数である物（定期券といったカード）を置き、求めたい面積を隣に並べます。
今回は求めたい面積を10円玉にしました。
上から撮影を行い、外接矩径の描画行なって、ピクセルを求めました。
その後、既知数の面積とピクセルの比から10円玉の面積を求めようとしております。

以下のソースコード実行すると、
カード幅 : 1757(px)
カード高さ : 1140(px)

硬貨幅 : 487(px)
硬貨高さ : 473(px)
が求まりました。
円形である硬貨の外接矩径を描いているため、硬貨の幅と高さのピクセルが同じにならないとおかしいのですが、なぜピクセルが縦と横で異なる数値がでるのか原因がわかりません。
どうぞ宜しくお願いいたします。


### 該当のソースコード

```python
from PIL import Image
import cv2
from datetime import datetime
import matplotlib.pylab as plb
import numpy as np
import sys

def main():
    img_org = cv2.imread('test1.jpg')
    # グレースケール化
    img_tmp = cv2.cvtColor(img_org, cv2.COLOR_BGR2GRAY)
    img_tmp_preprocessed = cv2.GaussianBlur(img_tmp, (5, 5), 0)

    # 2値化
    # - cv2.findContours()は、黒と背景、白を物体として判定する為
    #   cv2.THRESH_BINARY_INV で 2値化し、ネガポジ反転
    # - cv2.THRESH_BINARY は単なる2値化
    ret, img_tmp = cv2.threshold(img_tmp_preprocessed,
                                 128,                  # 閾値
                                 256,                  # 画素値の最大値
                                cv2.THRESH_BINARY_INV) # 2値化type

    time_str = datetime.now().strftime("%Y%m%d_%H%M%S")
    tmp_file = 'tmp_' + time_str + '.png'
    cv2.imwrite(tmp_file, img_tmp)

    # 境界線探索
    # - 第2引数:
    #   - cv2.RETR_EXTERNAL は最外周のみ探索
    #   - cv2.RETR_TREE     は全境界を探索
    # - 返り値:
    #   - contours : 探索された境界
    #   - hierarchy: 境界が複数ある場合の階層
    contours, hierarchy = cv2.findContours(img_tmp,
                                                 cv2.RETR_EXTERNAL,
                                                cv2.CHAIN_APPROX_SIMPLE)

        # 境界の描画 ( img_org データに contours データをマージ )
    cv2.drawContours(img_org, contours, -1, (255,0,0), 10)

    new_file = 'new_' + time_str + '.png'
    cv2.imwrite(new_file, img_org)

    for contour in contours:
      x, y, w, h = cv2.boundingRect(contour)
      cv2.rectangle(img_org, (x, y), (x + w, y + h), (0, 255, 0), 3)
      #画像保存
      new_file = 'new_' + time_str + '.png'
      cv2.imwrite(new_file, img_org)
      #x座標,y座標,高さ,幅の検出
      print(x)
      print(y)
      print(w)
      print(h)


if __name__ == '__main__':
    main()
```